Category: Uncategorized

ChatGPT, the most advanced conversational AI chatbot yet publicly revealed, is taking the world by storm. Millions of ordinary people are using it, and most are highly enthusiastic about its ability to create human-like written content that helps them in their daily lives. Software professionals, too, are taking note of this new kid on the AI block. For them ChatGPT is a portal into a future in which AI-augmented software engineering will inevitably disrupt traditional approaches to coding, maintaining, and updating the software applications modern businesses depend on.

As an article in the Harvard Business Review puts it,

“ChatGPT Is a Tipping Point for AI … The ability to produce text and code on command means people are capable of producing more work, faster than ever before… This is a very big deal. The businesses that understand the significance of this change — and act on it first — will be at a considerable advantage.”

In this article, we’ll use ChatGPT as an up-to-the-minute example of what AI-augmented software engineering can accomplish.

What Is AI-Augmented Software Engineering?

According to IEEE (the Institute of Electrical and Electronics Engineers),

Augmented intelligence is a subsection of AI machine learning developed to enhance human intelligence rather than operate independently of or outright replace it. It’s designed to do so by improving human decision-making and, by extension, actions taken in response to improved decisions.

AI-augmented software engineering applies the augmented intelligence concept to the realm of software development, maintenance, and improvement. In its practical application, the term describes an approach to software engineering that’s based on close collaboration between human developers and AI-enabled tools and platforms that are designed to assist and extend (but not replace) human capabilities.

To illustrate the importance of the collaborative aspect of augmented intelligence, the IEEE report cites the example of one clinical study aimed at detecting lymph node cancer cells. In that study, the AI system used had a 7.5 percent detection error rate. The error rate for human pathologists was 3.5 percent. But when the human pathologists and the AI system worked together, the error rate was just 0.5 percent.

What Can Today’s AI Do?

Software professionals around the world are now using ChatGPT to gain first-hand experience with the ways an advanced AI platform can extend the capabilities of application developers. Their reports highlight the benefits modern AI tools can provide for software engineering teams:

• Writing New Code: According to one report, ChatGPT has “shocked” developers with its proficiency at writing code. As this user puts it, if you tell ChatGPT to do so, “it will happily create web pages, applications and even basic games” in any of the programming languages (such as C, Java, HTML, Python, etc.) that are widely used today. But, as we’ll see below, today’s AI still has some significant limitations in this area.
• Explaining and Documenting Existing Code: One of the greatest benefits of ChatGPT is that you can give it a piece of existing code, ask what the code does, and receive a lucid, accurate explanation written in plain language. For developers working with legacy code, which is often highly opaque because of inadequate documentation, that’s a huge benefit that only an advanced AI platform can provide. In fact, the explanations the AI engine provides are so clear and well-written, they can also serve as a great learning tool for less experienced developers.
• Enhancing QA and Defect Remediation: ChatGPT can analyze a piece of code to detect and explain bugs that human developers may overlook. It can also suggest fixes for the errors it uncovers. Advanced AI platforms can automate software testing to a significant degree, substantially shortening the development cycle.
• Translating From One Language/Environment to Another: Developers can present ChatGPT with code written in one language and have that code accurately translated into the syntax of another language with which the coder may be less familiar.
• Turbo Charging Low-Code/No-Code Development: Low-Code/No-Code (LCNC) is already having a big impact on operations in many companies. It allows business users, who may have few technical coding skills, to automate processes in their workflows with minimal assistance from IT professionals. The ability of ChatGPT to produce working code based on natural language inputs democratizes software creation even more. It is, as one observer put it, LCNC on steroids.

Related: Using Machine Learning to Measure and Manage Technical Debt

What Does AI-Augmented Software Engineering Mean for Developers?

A key aspect of the IEEE definition of augmented intelligence is that it affirms that the purpose of AI-augmented software engineering is not to replace the human element but to assist and enhance it. Jorge Hernández, a Sr. Machine Learning Research Engineer at Encora, explains how this works:

AI-augmented software development helps reduce the cognitive load throughout the software development lifecycle … by helping manage the complexity of the problem, allowing workers to off-load routine tasks to the AI so that they can focus on the creative and analytical tasks that humans do best.

Today’s AI can relieve developers of many tasks that are either mundane and repetitive or, on the other hand, forbiddingly intricate and complex, freeing them to focus on higher-level responsibilities such as architecture and overall design.

For example, by intelligently selecting generic or boilerplate code from the open-source universe and adapting it to the current use case, an AI-augmented coding assistant can relieve developers of the more trivial aspects of the software development process. As technical consultant Rob Zazueta says, “I can take that, modify it to fit my needs and cut through boilerplate stuff quickly, allowing me to focus on the more intensive kind of work the AI is not yet ready to handle.”

Similarly, by uncovering, explaining, and correcting bugs in complex legacy code, an advanced AI platform can save human engineers hundreds of hours of analysis and remediation time.

Deepak Gupta, CTO at LoginRadius, summarizes the impact of AI-augmentation in software engineering this way:

“Artificial intelligence is revolutionizing the way developers work, resulting in significant productivity, quality and speed increases. Everything — from project planning and estimation to quality testing and the user experience — can benefit from AI algorithms.”

Limitations of AI

It’s important to remember that AI engines don’t really think—they simply use patterns they discern in their training data to predict an appropriate response based on the parameters they are given. So, they don’t understand the real-world context of the issues they address. As a result, they can make egregious errors that would be obvious to a human.

For example, although the ability of ChatGPT to turn natural language descriptions into code is extensive and impressive, it has significant limitations in producing usable code on its own, especially for non-trivial coding problems.

When given complex coding tasks, ChatGPT sometimes produces code that, as one software expert put it, “may work but may also almost work.” That is, the code may look as though it does what the developer specified, but have non-obvious flaws that make it unreliable. Needless to say, such code is the stuff of developers’ nightmares.

So, we’re nowhere near the point where software engineering can simply be turned over to an AI coding engine. But what AI-enabled platforms can do is produce code that human developers can use as a starting point, saving time and avoiding many of the bugs that humans themselves inevitably introduce into their code when they start from scratch.

Related: Common Pitfalls of App Modernization Projects

What AI-Augmented Software Engineering Means for App Modernization

Because legacy codebases may be huge (often five million lines of code or more), and may contain embedded dependencies and hidden functionalities that are not obvious to the human eye, refactoring a monolithic legacy app to a microservices architecture is a task that’s normally too complex and time-consuming to be done manually. But when AI and human developers collaborate, app modernization can become a much quicker and safer process.

First, AI can provide insight into legacy codebases that human engineers would struggle to acquire on their own. With AI, the process of analyzing legacy apps to determine if and how they should be modernized can be substantially automated, and the ability of the AI platform to almost instantly assess what a legacy code module is doing and how it functions can save engineers hundreds of hours of analysis time.

AI can significantly streamline and automate the creation of microservices, giving engineers and architects the ability to understand the most effective entry points into a microservice and decide appropriate domain boundaries.

AI can also allow developers to prototype various solutions, helping them understand the practical implications and benefits of each approach. Without AI, developers are effectively working in the dark, spending time and taking risks to experiment. AI brings visibility to the entire process—to what’s been done, what’s being done now, and the probable outcomes of specific “what if” scenarios.

In general, the task of modernizing legacy apps is too complex for humans alone to handle, while AI systems lack the strategic and contextual understandings required for formulating optimal business solutions. But when engineers and architects work collaboratively with a modern, sophisticated AI assistant, they can modernize applications far more quickly, with greater confidence and less risk.

Applying AI-Augmented Software Engineering To App Modernization

The vFunction platform is specifically designed to apply AI augmentation to the task of legacy application modernization, transforming a process that, when done manually, is complex, time-consuming, risky, and costly. With its advanced AI capabilities, vFunction can automatically analyze huge monolithic codebases, and substantially automate the process of refactoring them into microservices. vFunction speeds up the modernization process by a factor of 15 or more while reducing overall costs by at least 4X.

If you’d like to see how AI-augmented software engineering can lift your legacy app modernization programs to entirely new levels, schedule a vFunction demo today.

It Takes a First-Class Seat: Demonstrating the Benefits of  Continuous Application Modernization 

Continuous application modernization allows organizations to address legacy code in iterative steps. It adheres to an agile-like methodology where incremental improvements are delivered faster with less risk than traditional waterfall methods, where multiple updates are delivered at once. However, an effective agile environment requires a mindset change. 

Anyone promoting a continuous application modernization strategy must overcome the tendency to resist change. Individuals are hesitant to accept change when they do not understand its impact. That holds for employees as well as executives. In fact, organizational resistance to change is a primary obstacle to implementing new processes. 

Executive buy-in or the lack of leadership support contributes to an organization’s fear of change. Unless management participates in the process, employees hesitate to invest their energies because they do not see a benefit. The proposed change is another “fad” that will be replaced in a month or two. Why invest time and energy in a process that will disappear in a few months?

To ensure project success, IT must first get executive support. Without it, IT departments will encounter employee resistance. So how does IT achieve executive and employee buy-in?

Before you talk about ROI, risk assessments, and budgets, consider the psychology of change. Change management gurus and psychologists cite fear of failure, fear of the unknown, and fear of job loss as reasons for resisting change. However, resistance indicates the reward is not worth the risk.

For example, you have an aisle seat in coach on a full flight from LA to JFK. Just before take-off, the airline offers you a free upgrade to a first-class window seat. Are you going to turn down the upgrade because it requires a change? Probably not.

The same psychology applies to leadership buy-in. If you want executive support, you need to offer them a first-class seat. The question is, how do you do that?

Related: Creating a Technical Debt Roadmap for Modernization

Leadership Support for Continuous Application Modernization Strategies

Gaining leadership support means presenting information that demonstrates to executives that using a continuous application modernization strategy is in the company’s best interests. The rewards of a more agile development environment offset any risks associated with the strategy change. The secret to success is how the data is used to achieve buy-in.

Begin with Data

Companies have more projects than resources. It’s the leadership’s responsibility to decide which projects have priority. They want data to help with decision-making. Executives want to know that the appropriate due diligence has been conducted to determine the project’s scope and cost. 

The first step in proposing continuous application modernization is quantifying technical debt. IT must assess the time, costs, and scope to determine debt accurately. The process is time-consuming unless automated tools are used. For example, IT can manually calculate defect ratios by tallying old and new defects, or they can use bug-tracking software to store the information. Other metrics for assessing technical debt include:

• Code quality using coding standards
• Completion time using hours to correct a reported problem
• Rework efforts using bug-tracking software
• Technical debt ratio comparing the cost to fix problems versus the cost of building new

While these methods can reduce the assessment time, they still require IT to perform calculations and analysis. Fully automated solutions can eliminate much of the collection, analysis, and calculation required to present a business case for executive buy-in.

AI Modernization Platforms

AI-guided solutions can reduce the assessment time from weeks to hours with little to no IT involvement. For example, AI-automated assessment tools can analyze Java code in less than an hour, providing information on the following:

• Technical Debt. Identify sources and measure negative impact if not addressed.
• Complexity. Quantify the complexity of each application and prioritize the apps to modernize first.
• Metrics. Assess metrics for return-on-investment analysis

Using a fully automated platform enables IT personnel to spend less time collecting data and more time focusing on the benefits that will deliver buy-in. 

Define the Process

Many outside of IT may not be familiar with the concept of continuous application modernization. They may not understand how the process differs from more traditional approaches to software development. Part of the buy-in process means explaining how the change impacts an organization.

Suppose a company has a payment processing solution that needs updating to support a different payment type. The project has a three-month deadline. As the project progresses, decisions are made to leave the architecture the same because recasting the payment type as a microservice would delay the release date.

After the software is released, the company can continue with its existing architecture, adding to its technical debt to be addressed decades in the future. Or, the company can add moving the payment type to a microservice to its list of modernization tasks and assign it a priority to decrease the technical debt as quickly as possible. 

The ramification to the company is the allocation of resources to work on modernization tasks as part of its routine workflows. That may mean fewer resources are available to work on other projects. For many, this process may seem to be a negative, taking away valuable resources to fix problems with software that is working just fine.

That’s when focusing on the benefits comes into play. It’s these benefits that will convince leadership that modernization is in the company’s best interest.

Focus on Benefits

Achieving executive support for continuous application modernization means addressing change in terms of benefits. It’s about using the data to inform the discussion on why continuous application modernization is the right strategy for an organization. Here are some tips on how to use data to demonstrate how modernization is the best choice.

Meet Key Business Objectives

Instead of talking about money and timelines first, talk about impediments to meeting business goals. Take the payment type example.

Suppose accepting crypto payments is a business objective. Start with what is needed to support that payment type, highlighting the technologies the existing architecture cannot support. Using the data from an automated analysis, explain the time and cost of modernizing the entire application. Be sure to note that the timeline assumes the use of automated tools.

Part of the discussion should include the impact on daily IT operations. When modernization occurs in a waterfall-like approach, all available resources will be consumed in the effort, leaving minimal IT staff to address everyday issues. Historical data should provide information on what percentage of staff time is used in system maintenance activities and support. 

Contrast the waterfall scenario with a continuous application modernization strategy that uses iterative development. With a prioritized analysis, discuss a timeline where microservice development is integrated into standard IT operations. Then, compare the timelines. Which approach is more likely to meet business objectives with less disruption and at a lower cost?

Improve Agility

Comparing timelines opens the discussion to another critical business objective — agility. Leadership is well aware of agility’s value to a company’s long-term viability. What they don’t know is how to achieve it. That’s where a continuous application modernization strategy comes in.

Related: IT Leader Strategies for Managing Technical Debt

Consider compliance updates using the payment example. Payment networks have annual or semi-annual updates that must be completed as scheduled to remain in compliance and continue payment processing. What happens when an update is required in the middle of modernization? 

Using data from an automated analysis, IT can determine which microservices are impacted by the updates. They can look at the project schedule and determine the impact on deliverables. A low-priority microservice may need to be higher on the list. If the modernization assessment presents the data per microservice, adjusting the timeline should be straightforward with little impact on the overall schedule.

A waterfall-based strategy could lead to difficult decisions. 

1. If the modernization project is months away from completion, updates must be made to the existing code to remain in compliance. Updates will also need to be added to the modernization code to ensure backward compatibility. When the new code is delivered, the updates may require retesting or recertification since it is a new code base.
2. If the project is close to completion, the updates can be added to the new code. The existing code would remain untouched. If the new code is not ready as anticipated, the company is out of compliance and risks penalties and fines. The added updates may extend test times. 

The compliance example illustrates continuous modernization’s agility. While the changes may impact overall delivery schedules, the strategy delivers the agility needed to ensure operations with minimal risk.

Achieve Buy-In for Continous Application Modernization

Focusing on benefits still requires a detailed analysis of what modernization will take. It needs the same data as is needed if using a more traditional time and materials approach. The difference is in the seat location.

In coach, the executives struggle to see where the plane is going and the turbulence ahead. They cannot reduce the noise to decide what is in the company’s best interests. In first class, leadership encounters less noise and has a clearer perspective of the plane’s path. They are less resistant to change because they see the long-term advantages of a continuous application modernization strategy.

vFunction’s Assessment and Modernization Hub provides organizations with data-driven analysis of what is needed for modernization. The data can then be used to get leadership buy-in when focusing on what facilitates change. Contact us today to get started gaining leadership support for your modernization projects.

As technology continues to evolve, businesses are increasingly turning to microservices and containerization to improve their IT operations. Container management is the process of overseeing and maintaining the containers that hold the microservices in a distributed system. It enables the efficient deployment, scaling, and management of microservices. 

By understanding container management, you can better navigate the complexities of microservices and gain insight into the best practices and tools to deploy and maintain them efficiently. Defining what it is, why it’s used, and why a management strategy is needed will lead to more effective operations and better overall performance of your IT systems. Here’s what you need to know about container technology.

The Role of Virtual Machines in Container Technology

Container technology grew out of virtual machine partitioning in the 1960s. Virtual machines (VM) let multiple users access a computer’s full resources through a single application. VMs were used to install multiple operating systems and applications on a single server.

Unlike VMs, containers have shared resources. Many deployments used multiple microservices in a single container. That complexity hindered container usage until automated management tools were developed. Now, system architects have access to solutions that make containerization software more reliable. These tools make up what is known as container management.

In contrast to VMs, containers require fewer resources and are faster to initialize, but those capabilities often make deployment more complex. When virtual machines were first introduced, developers used them to install multiple operating systems and applications on a single physical server, each in their own isolated environment. 

Instead of having multiple servers running different development environments, IT could maximize the use of physical servers through VMs. However, they were resource-heavy and slow to spin up.

Security was not a major concern when VMs first hit the market, so their deployment allowed unrestricted access to any environment running on the same device. In the 1980s, developers began looking at ways to restrict access to improve system security. Limiting file access to specific directories was the start of container-style processes. 

The Growth of Container Technology

Docker released its container platform in 2013. It was a command-line, open-source solution that made container deployment easy to understand. It was well-received, and within a year, the software was downloaded over 100 million times.

In 2017, Google’s Kubernetes became the default container tool as it supplied scheduling and orchestration. When Microsoft enabled Windows Server to run Linux containers, Windows-based development could take advantage of the technologies. That change opened the door to more container-based deployment.

As more organizations moved to the cloud, container management became a concern as deployment and monitoring remained complex. Today, many cloud providers offer managed container services to deliver streamlined solutions with independent scalability. Ongoing development looks to incorporate AI technologies for improved metrics and data analysis, leading to error prediction, incident resolution, and automated alerts. 

RELATED: Monoliths to Microservices: 4 Modernization Best Practices

According to Statistica, the container market is expected to reach $5 billion US dollars in 2023 with a year-on-year growth rate of 33%. Whether considering or expanding the use of container technologies, organizations should develop a strategy for how to incorporate container management into their modernization plans.

To understand the role this technology plays in a company’s efforts to reduce its technical debt, IT staff should evaluate the landscape, beginning with what container management entails.

What is Container Management?

Containers are virtual operating systems that allow applications, their libraries, and dependencies to operate in one deployable unit. Often used in conjunction with microservices, containers enable multiple applications using the same operating system kernels to function as self-contained code. Containerization makes for lighter-weight implementations with greater interoperability than VMs. 

However, containers have to be managed. They have to be deployed, scaled, upgraded, and restored. As more companies look to cloud-native containers, managing hundreds or thousands of them becomes overwhelming. That’s why the market for container management continues to grow. 

Gartner defines container management as:

A set of “tools that automate provisioning, starting/stopping and maintaining of runtime images for containers and dependent resources via centralized governance and security policies.”

Container management solutions may be platforms that operate as software-as-a-service or software solutions installed locally. Container management enables developers and administrators to realize the benefits of containerized microservices while minimizing potential errors.

Why Use Container Management?

Container management tools simplify the deployment and monitoring of containers. With these tools, IT can stop, start, restart, and update clusters of containers. Automated tools can orchestrate, log, and monitor containers. They can perform load balancing and testing. 

IT departments can set policies and governance of a containerized ecosystem. As more organizations move to a container infrastructure, they will need automated tools to manage large environments that are too much for staff to maintain.

Other benefits of container management tools are:

• Portable. Containerized applications can be moved from the cloud to on-premise locations. They can move to third-party locations without integration concerns, as the technology does not depend on the underlying infrastructure.
• Scalable: Microservices can scale independently with minimal impact on the entire application.
• Resilient: Different containers can hold applications so that a disruption in one container does not result in a cascading failure.
• Secure: Unlike VMs, containers isolate applications. Gaining access to an application in a container does not automatically give bad actors access to others.

Containers are lightweight with minimal overhead, making for fast deployment and operation. However, turning monolithic legacy code into containerized microservices can introduce vulnerabilities unless carefully orchestrated. Container management is not without its challenges.

What Are Container Management Challenges?

Management complexity and the lack of a skilled workforce are the primary obstacles to containers and their management. For example, containers only exist when needed. When a container is no longer required, it spins down, taking all of its data with it. Maintaining persistent data across containers poses significant problems if not well managed. 

Complex Container Management

What happens when a container needs data that is no longer available? How can developers ensure data is persisted? How can they identify these errors with hundreds of clusters of containers to manage? Without container management, it’s almost impossible for developers and architects to deliver an error-free implementation.

Application isolation protects against VM-type vulnerabilities; however, orchestrators can expose containers to attack. APIs, monitoring tools, and inter-container traffic increase the attack surface for hackers. Using security best practices, such as only using trusted image sources, reduces authentication and authorization weaknesses. Closing connections minimizes the number of entry points for bad actors. 

Lack of Skilled Staff

The most significant challenge is the lack of experienced staff. Organizations need a thorough understanding of the scale and scope of a containerization effort. They need a roadmap that outlines how existing code connects and communicates to ensure relationships are retained. Since containers can run in multiple environments, architects must define the business objectives behind the move to modernization to ensure the right infrastructure is in place.

A recent Gartner survey found that Kubernetes and infrastructure-as-code were the most sought-after skills. Some organizations are developing expertise centers. These groups are tasked with helping in-house staff as needed while using the opportunity to train others to reduce the skills gap. Others are looking for outside sources to help with knowledge transfer. 

With the drive to modernization using microservices and containers, companies need a container management strategy to address the critical challenges that a complex container architecture can present. Without a reasoned strategy, organizations face a technical debt greater than that of legacy code.

Why is a Container Management Strategy Needed?

Container management should be part of any modernization strategy. However, its complexity requires a roadmap that includes the following:

• Isolation of users and applications
• Authentication and authorization protocols
• Resource management
• Logging and monitoring
• Long-term container usage
• Multi-cloud platforms
• Microservice development

The plan should include methods to address edge computing, cloud implementations, modernization, and training. 

Implementing Edge Computing

With edge computing, the volume of data makes management difficult. Moving all the data to a central location poses performance concerns since much of the data is being captured at the edge. More organizations are looking at building edge infrastructures to prepare the data before sending it to the cloud for processing. 

Containerizing applications at the edge to allow data ingesting and cleaning should be part of any strategy. Containers can improve AI implementations or data-intensive processing and reduce cloud storage costs by placing them close to the data acquisition point.

Refactoring Cloud Implementations

Within the last three years, many organizations have moved all or some of their infrastructure to the cloud. Unfortunately, for many, the move was rushed. Monolithic applications that were migrated (lifted and shifted) to the cloud or simply containerized as a full monolith were brittle and could not scale or be updated without refactoring or rewriting. Making architectural changes would require careful planning by developers and business units to minimize disruption without compromising modernization.

RELATED: Four Advantages of Refactoring that Java Architects Love

Companies cannot assume that simply migrating an application to the cloud removed any technical debt at all. By refactoring cloud implementations, IT departments can ensure that their cloud deployments reduce technical debt.

Modernizing Monolithic Applications

Breaking monolithic software into microservices and containers requires a roadmap that helps developers navigate a way forward. A migration strategy also highlights skills gaps that can be addressed before modernization is underway. As container management tools improve and more organizations move to a cloud-native environment, a clear strategy is needed to ensure that the migration does not increase technical debt. 

Few modernization efforts can be completed at once. The so-called big bang approach increases delivery times and introduces many of the same issues that monolithic structures present. Iterative approaches make managing thousands of lines of code more manageable and reduces the risk of operational disruption. 

The vFunction Modernization Platform and Container Management

vFunction’s refactoring platform for Java and .NET applications can help organizations realize the benefits of container management. Using its platform, organizations can decompose monolithic apps into microservices for container deployment in cloud-native environments. The platform can serve as a tool for developing well-constructed microservices that minimize the risks to container implementations. 

As companies plan for 2023, they will look to containers and their management as a modernization path. Without a complementary modernization strategy, the resulting infrastructure can prove problematic. For help modernizing Java and .NET applications that take advantage of the cloud environment, contact us to see how we can work with you to develop a strong implementation strategy.

Part 4 in the Uncovering Technical Debt Series from Intellyx, for vFunction. [Check out part 1 | 2 | 3 here.]

We’ve dug deep into our technology stacks, uncovering all of the legacy artifacts and monoliths that we could find from past incarnations of our organization. 

We’ve cataloged them, rebuilt them to modern coding standards, and decoupled their functionality into object-oriented, service-enabled, API-addressable microservices.

Now what? Are we modernized yet? 

Well, mostly. There are always some systems that just aren’t worth the time and attention to replace right now, even with intelligent automation and refactoring solutions.

Plus, we acquired one of our partner companies last year, and we haven’t had a chance to merge their catalog with our ordering system yet, so they are still sending us EDI dumps and faxes for urgent customer requests…

We’re never really done with continuous modernization

We’ve compared legacy modernization to the discipline of archaeology. But what happens once archaeologists finish their excavation and classification expeditions? Anthropologists can take over the work from here, interpreting societal trends and impacts even as the current culture continues to evolve and generate new artifacts. 

Similarly, discovering and eliminating uncovered technical debt isn’t a one-time modernization project, it’s a continuous expedition of reevaluation. Once an application is refactored, replatformed or rearchitected, it creates concentric ripples, exposing more dependencies and instances of technical debt across the extended ecosystem, including adjacent applications within the organization, third-party services and partner systems.

Mapping the as-is and to-be state of the codebase with discovery and assessment tools is useful for prioritizing the development teams’ targets for each project phase around business value, but business priorities will change along with the application suite. 

Development teams also get great utility from conducting modernization projects with the help of AI-driven code assessment and refactoring solutions like vFunction Code Copy, but they can realize even greater benefits by retaining the history of what worked (and didn’t work) to inform future transformations.

Not every modernization project works out equally well, but when the hard lessons of modernization feed back into the next assessment phase, this virtuous cycle can become part of the muscle memory of the organization, allowing mental energy to be spent on the most important choices that affect the long-term goals of the business.

Putting technical debt to rest: what to expect

No computer science college student or self-taught coder sets out to spend a career finding and fixing bugs in their code, much less someone else’s – but on average, developers spend at least 30 to 50 percent of their time on rework, rather than innovation and enablement of new features that are perceived to add business value.

Besides the perceived thanklessness of the effort, developers encounter morale-destroying toil when sifting through legacy code, which usually contains lots of class redundancies, recursive methods, poor documentation and a general lack of traceability, resulting in slow progress.

Continuous modernization offers a way out of this thankless job, by preventing technical debt from collecting during each assessment and refactoring phase. 

Here’s some levers teams are pulling for successful long-term improvements:

• Continuous assessment. The best performing initiatives are not just conducting initial assessments, they are continuously mapping, measuring and observing modernization efforts before, during, and after each refactoring run.
  
• FinOps practices basically bring financial concerns and tradeoffs to each modernization selection process or option. IT buying executives have been doing ROI analyses for vendor selection and capex computing investments for years. Now, savvy buyers are getting better cost justification for money spent on modernization, with real financial metrics for resources, employee and customer retention, and delivered customer value. 

• SLO objectives offer positive motivation for time-and-labor savings and incremental delivery of new services, in comparison to the negative contractual penalties enforced through SLA failures. Developers are incentivized to meet goals such as faster refactoring projects, faster automated deployments, and higher value updates – with fewer hitches and developer rework required.
  
• Qualitative business goals are equally as important to success. Better team morale improves productivity and employee retention rates, versus trying to replace high-quality people with new ones that could take months to get up to speed. Developers love working for agile enterprises, where they can test theories and ultimately help the application suite evolve faster in the future to meet changing customer needs.

Trending toward velocity and morale at Trend Micro

Trend Micro is considered a global leader in cloud workload security, with several successful products underneath the banner of its platform – but that didn’t mean their modernization journey started without major headaches. 

Much of their existing product suite, with more than 2 million lines of code and 10,000 independent Java classes, was built before secure API connections between cloud infrastructure and microservices were fully sussed out by the development market. Therefore, earlier customers were more inclined to trust on-premises installations and updates of vital virus, spam and spyware prevention software.

As the modern trends of SaaS-based vendors and cloud-based enterprise applications really hit stride over the last decade, Trend Micro started offering a re-hosted version of its suite under their CloudOne™ Platform banner.

Their initial lift-and-shift of one module’s code and data store to AWS offered some scalability and cost benefits due to elastic compute resources, but as the user base grew, it was becoming harder and harder for product dev teams to get a handle on inter-product dependencies that hindered future releases and updates to meet customer needs. Morale suffered as the replatforming took about a year.

Trend Micro turned to vFunction to identify and prioritize modernization of their most critical “Heartbeat” integration service – with more than 4000 Java classes that take in data from sensors, event feeds and data services across the product suite.

Then using vFunction for modernization, the team was able to visually understand code complexity, with an applied AI for identifying essential, interconnected and circular dependencies, deprecating dead code that would no longer add any actual value for customers going forward.

Through refactoring, they were able to decide which classes should be included as part of the new Heartbeat service, and which should be kept in a common library for shared use across other product modules in the future.

This modernization project took less than 3 months – a 4X speed improvement over the previous project, with successive update deployment times decreased by 90%. Best of all, morale on the team has improved by leaps and bounds.

The Intellyx Take

Continuous modernization offers enterprises a lasting bridge from the monolithic past to a microservices future, but with constant change at enterprise scale, the journeys across this bridge will never really end.

To get to the bottom of the biggest obstacles of modernizing our digital estates, we must first assess and prioritize code refactoring and application architecture efforts around resolving technical debt.

Then, our intrepid teams can venture forth, digging to unearth the artifacts and digital foundations of our organizations, transforming our applications into modular cloud native services, resetting the values of our shared culture, and adapting our architectures to meet the challenges of a global, distributed, hybrid IT future.

Can you dig?

©2022 Intellyx LLC. Intellyx retains editorial control of this document. At the time of writing, vFunction is an Intellyx customer. Image credit: Licensed from Alamy “2001: A Space Odyssey” movie still.

In today’s market environment, the ability to quickly take advantage of new technological capabilities is of paramount importance to a company’s ability to maintain or enhance its competitive position. That’s why for many businesses, the modernization of their legacy application portfolio has become not just a high priority but an existential necessity.

The problem such organizations face is that the legacy apps they depend on for some of their most essential business processes actually hinder their ability to keep pace with rapidly changing technological and marketplace conditions. Stefan Van Der Zijden, VP Analyst at Gartner, puts it this way:

“For many organizations, legacy systems are seen as holding back the business initiatives and business processes that rely on them… application leaders must look to application modernization to help remove the obstacles.”

The Importance of Application Modernization

Legacy apps are typically structured as monoliths, meaning that the codebase is organized as a single, non-modularized unit that has functional implementations and dependencies interwoven throughout. Updating such code to interoperate with the cloud-native systems and resources that dominate today’s technological landscape is difficult, time-consuming, risky, and costly.

To overcome this difficulty, organizations must modernize their legacy monolithic codebases to convert them into modern, cloud-native applications that can easily integrate into today’s technological environment. 

Most companies have not only recognized this fact but are acting on it – in a recent study conducted by Wakefield Research, 92% of respondents said their companies are either currently modernizing their legacy apps or are actively planning to do so.

Challenges of Application Modernization

Although application modernization is now considered by many companies to be essential, getting it right can be difficult. According to the Wakefield study, 79% of application modernization projects fail to achieve their goals. 

Application modernization efforts have historically been time-consuming and costly: the typical modernization project lasts 16 months and costs about $1.5 million—and more than a quarter of Wakefield survey respondents (27%) say their projects took two years or more. In a recent survey, 93% of respondents characterized their modernization experience as “extremely or somewhat challenging.”

Related: App Modernization Challenges That Keep CIOs Up at Night

App Modernization Pitfalls to Avoid

Let’s take a look at some common pitfalls that can, if you fail to avoid them, add your project to that 79% failure rate:

1. Inadequate Management Support

Buy-in by an organization’s executive management team is indispensable to the legacy app modernization success. In the Wakefield survey, both executives and architects cited a lack of “prioritization from management” as a major factor that “stopped modernization projects in their tracks.”

If a company’s executive management isn’t on board with the necessity for legacy app modernization and with the ROI such projects can be expected to yield, the budget, personnel, and other required resources either won’t be supplied at all or won’t be maintained at an adequate level. 

When changing marketplace conditions cause the organization to readjust its priorities, modernization projects can sometimes lose the management focus and budgetary support needed for success. To avoid that happening, you must be prepared to make and remake the case for the business utility and ROI of your modernization efforts as marketplace conditions continually evolve.

2. Failure to Adequately Address Cost Concerns

Nearly 50% of both executives and architects in the Wakefield study agreed that securing the needed budget and other resources is the most difficult step in implementing a modernization project. That’s typically because the executives who control the purse strings haven’t been given reliable information that convinces them that the return on the not-inconsiderable investment required for such projects will be great enough to justify the financial and business risks.

By conducting a  data-driven assessment of your legacy application estate, you can provide your organization’s management team with accurate, quantified data that makes the business case for investing the budgetary and other resources an app modernization project will require.

3. Misalignment Between Business and Technology Teams

The Wakefield study reports that 97% of survey respondents expected that someone in their organization would push back against modernization proposals. Such objections commonly occur when various stakeholders are not on the same page. Here are some typical reasons why that may occur:

• The risk seems too great—Because legacy app modernization involves significant changes to critical systems, there is a definite degree of risk attached to such efforts. In the absence of trustworthy information and specific, well-developed plans that mitigate the risk factors, business and IT stakeholders may be reluctant to accept the risks to business operations that a modernization project represents.
• Stakeholders fear large-scale change—When legacy applications are modernized, some associated workflows will usually also change. Well-established processes may be altered, and workers may need to be retrained or reassigned. Such developments introduce levels of uncertainty and instability that business stakeholders may be wary of.
• Stakeholders fear losing their role—The business process changes that arise from app modernization efforts may threaten the traditional roles of some stakeholders or seem to relegate their perspectives and concerns to a lower priority level.

To avoid having such concerns become sources of pushback, stakeholders should be presented with a well-developed, data-driven modernization plan that addresses their unique issues.

4. Failure to Accurately Set Expectations

In the Wakefield study, this was the #1 reason given by respondents who started modernization projects they didn’t complete. Areas of particular concern include unrealistic expectations relating to budget and schedule requirements and anticipated project results such as improvements in engineering velocity and application innovation. 

To overcome this obstacle you need to be able to supply stakeholders with accurate, quantified data regarding the complexity of the task and the timeframe and budget that will be required for completing it.

In addition, you must ensure that your modernization methodology can produce the results you promise. Companies often make the mistake of thinking that just moving an application to the cloud will provide an acceptable degree of modernization. That’s not the case. Such a migration (often called a “lift and shift”) retains all the disadvantages of the application’s monolithic architecture. 

True modernization only occurs when the app is not only migrated to the cloud but is refactored from a monolith to a microservices architecture. Only then will you fully reap the benefits that make a modernization project worthwhile.

5. Failure to Make Required Organizational Structure Changes

App modernization is far more than just a technical exercise. IBM puts it this way:

“A cultural transformation is also imperative. Organizational roles, business processes and IT skills must evolve and advance for your cloud migration and application modernization to be a success.”

According to Conway’s Law, the organizational structure of a software development group must align with the structure of the application they intend to produce. When that doesn’t happen, an app modernization project is headed for trouble. Software engineer Alex Kondov is adamant that “you can’t fight Conway’s Law,” and supports that declaration with this observation:

“Sadly, often a company’s structure may not support the system it wishes to create. Time and time again, when a company decides that it doesn’t apply to them they learn a hard lesson.”

6. Inadequate Skills or Training

A legacy app modernization project is a complex process that requires a level of expertise many companies don’t have in-house. So it’s no surprise that almost a third of respondents to the Wakefield survey cited a lack of worker skills or training as a key obstacle to success. 

Yet, in today’s job market, hiring and retaining highly skilled software developers can be a time-consuming and costly process. You can reduce this requirement by providing your development team with modernization tools that embody skills your developers may lack.

7. Lack of Intelligent Tools

In the Wakefield survey, this was the #1 reason cited by software architects for app modernization failures. The process of refactoring monolithic legacy apps to convert them to a cloud-native microservices architecture is a highly complex undertaking that may require unraveling tens of millions of lines of code to expose hidden functionalities and dependencies in the codebase. 

Doing this using an essentially manual approach may require many months or even years of developers’ time, and even then the risk of an unsatisfactory outcome is extraordinarily high. On the other hand, the use of a state-of-the-art, AI-enabled, automated modernization tool can speed up the process by orders of magnitude while all but eliminating the risk factors that plague manual efforts.

Related: The Easy Way to Transition from Monolithic to Microservices

App Modernization Starts with Using the Right AI Tech

Many companies attempt to modernize applications using general-purpose design, analysis, and performance monitoring tools. But these have proven to be inadequate for the task. 

What’s needed is a tool that’s specifically designed for modernization, with advanced AI capabilities that allow it to comprehensively analyze monolithic applications, reveal hidden dependencies and functional implementations, and benchmark the levels of technical debt, complexity, and modernization risk associated with each app. It should also be able to substantially automate the process of restructuring complex monolithic apps into microservices.

vFunction provides just such an automated, AI-empowered tool. The vFunction Assessment Hub measures the complexity, technical debt load, and modernization risk of each app. The vFunction Modernization Hub then automates about 90% of the process of refactoring monolithic codebases into microservices. 

To see first-hand how vFunction can help you avoid the pitfalls that have wrecked so many application modernization efforts, request a demo today.