IT organizations need to deliver services at the speed that business demands. Keeping up with this pace is difficult when IT relies on applications with legacy architectural patterns or running on old infrastructure. What are the quick-win paths for modernizing legacy applications?
Source: BrandPost: 5 Quick-win paths to application modernization
Organizations have two main application types: need-to-work and need-to-win applications. Need-to-work applications help organizations get their work done, such as e-mail or collaboration tools. Need-to-win applications are the revenue generators and are absolutely critical for business success. Finding a quick-win path to make fast changes to these applications allows organizations to gain or strengthen their competitive advantage.
Some of the need-to-win applications are born in the cloud, run on modern software and infrastructure stacks, or follow cloud-native design patterns. However, a big proportion of the need-to-win applications are mission-critical applications running on old, proprietary, and inflexible infrastructure and software stacks that are extremely costly to maintain and do not provide the agility that the business requires. In an era that requires faster development, shorter deployment cycles, greater data insights, and/or connectivity with the edge, the modernization of these applications is a must for any organization.
Application modernization versus placement
But what does modernization mean? Recently, modernization meant how to transform your application to run on or off-premises. Organizations spent quite a lot of time and money to figure out the best place to run their applications. However, organizations companies have realized that, as the business evolves, the requirements for the applications evolve – and the best placement today might not be the right placement tomorrow. Modernization has shifted from solving a placement problem toward transforming applications to gain greater agility in the full lifecycle, architecture, and deployment options.
When defining the modernization path and with the objective to gain agility, there are three key principles that need to be considered:
- Adopt agile application architectures that allow changes faster to smaller elements of the application, or that are stateless so that you can scale on demand.
- Transform teams to achieve greater agility by embracing agile development and operations methods to match your agile application architecture. Embracing DevSecOps approaches must be at the heart of team culture.
- Modernize applications so that they can be deployed on hybrid cloud platforms, leveraging as-a-Service and self-service catalog experiences in order to shrink the internal supply chain and gain portability, scalability, and elasticity.
Quick-win paths
There are a wide variety of options but there are a few that help most organizations find the right balance between gaining agility versus the time and cost to modernize. These quick wins unlock more modernization options as well as budget resources that can be used to continue modernizing applications.
- Re-host and re-platform to hybrid cloud. The risk of modernizing core business and mission-critical applications is high. As a first step, move applications off legacy, aging, or non-strategic platforms. Examples: moving mainframe and UNIX workloads to Linux or Windows, or moving off a proprietary PaaS environment to avoid vendor lock-in. This may require technical modifications of the custom-coded applications to work on the target environment, such as system call and API changes. There are no changes, though, to the business logic or application language. Packaged applications can be re-platformed to the same or an alternative package. This approach provides the fastest migration, quickest ROI, shortest code freeze, and lowest risk option. At the same time, the target hybrid cloud will provide greater flexibility to scale on demand.
- Transform to modern languages and open source components using automation. Legacy application languages increase the complexity of application integration and the running cost due to resource scarcity. Proprietary components add to this problem as they increase the cost of running applications. My advice? Leverage automatic migration tools to transform aging languages to modern languages and proprietary databases and application servers to modern open source alternatives. Retain the same basic application architecture, while ensuring a fast migration using migration tools that extract to pseudo code or UML, then generate a pure target code. Transform to modern application languages for simpler maintenance.
- Containerize applications so they can be deployed anywhere within a hybrid cloud estate. Containerization, coupled with microservices architectures, provides true cloud-native applications. Even if the application follows a more rigid architecture pattern such as three-tier or monolithic, containerizing each tier separately will provide greater portability, reduce the deployment cycle, improve maintainability, and provide greater flexibility to scale-out.
- Re-architect to stateless and microservices. Traditional application architectures include monolithic programs that are complex, or applications where business and data logic is often spread across multiple programs. This increases the maintenance effort and impedes innovation. Furthermore, these applications are typically stateful in nature which makes them difficult to scale. Leverage domain-driven design techniques and automatic tooling to understand business logic – for example, by visualizing the logic in UML – to identify the business domains and application contexts that will go into each microservice. Start by extracting big parts of the application, and continue with an iterative process where they are decomposed into smaller parts and wrapped into remote stateless interfaces – REST APIs. As the microservices are extracted, build modules to dispatch requests to either the old monolithic part or the new microservices.
- Re-architect to cloud-native architectures. One more step in the journey: continue refactoring applications to adopt a pure cloud-native architecture. These architectural patterns allow the design of modular applications where components are loosely coupled, deployed automatically on each environment, or where there is a greater insight around the health of the service. There are design patterns that make applications elastic so that resources are allocated on demand and adjusted to the resources required, or patterns that allow the discarding and replacement of component instances to allow the system to heal.
Where to start?
Launch, without delay, a transformation program that matches applications to quick-win paths and executes modernization now to reduce cost, time to market, and leverage the portability, elasticity or scalability benefits that the hybrid cloud offers.
For further information contact: [email protected]
____________________________________