Way back in 2001, a small group of people issued a manifesto that came to revolutionize the world of software development. The principles underpinning this movement, known as agile development included a commitment to the end user, an ability to adapt to changing requirements, frequent delivery, collaborative work environments, results orientation, maintainability, simplicity, and constant improvement.
Over the years, many interpretations and related development frameworks have been made based on these core principles. At the heart of all of these is the need to divide the development process into smaller pieces and deliver the product in an iterative process testing at every step of the way.
IT professionals soon recognized that these principles could be applied to application maintenance and operations just as they had to software development. Over time, these systems of agile operations led to the new paradigm of DevOps. Under DevOps, operations and development IT staff work together to constantly deliver new or better functionality to the end user in an iterative manner as under agile. DevOps approaches generally favor the use of toolchains to automate this process as much as possible. John Willis summed up DevOps with the acronym CAMS, signifying Culture, Automation, Measurement, and Sharing. DevOps is a culture that promotes the collaboration between various partners in the improvement of IT, favoring automation of processes, and insisting on both the measurement of results and the sharing of this information between the parties.
Many of these principles can be applied to the process of legacy modernization. In fact, the focus on end user functionality common to agile and DevOps, all but necessitates the modernization of legacy systems to support in-demand digital technologies, especially cloud and mobile platforms. The DevOps approach also empowers us with tools to fight the often-cited statistic that less than 50% of legacy modernization projects succeed. Specifically, modernization projects need to be iterative, automated, and incremental.
First and foremost, legacy modernization needs to be an iterative process. The intricacies of dealing with decades’ worth of legacy code in a variety of forms and flavors adds complexity that can be difficult to discover beforehand. However, if a project is broken into discrete iterations, learning can occur throughout the process. Breaking a project down into smaller parts also reduces the scope of any code freezes that may be required during the modernization. Furthermore, an iterative process allows testing to begin early in the process and continue throughout. This way functional equivalence and adequate performance can be assured long before the application finally goes live.
Second, the process should be as automated as possible. Automation adds both speed and precision to a process that has traditionally taken prohibitively long using traditional rewrites. While automation is critical to a successful modernization process, it must be noted that it is not the only part of the modernization. Theoretically a tool could convert millions of lines of code in an afternoon, but we know that successful modernization projects take much longer. DevOps is said to favor people over process over tools. What this means in a modernization is that the modernization process must empower the engineers to use the tools to deliver the best maintainable results for the user. A one click process might be fast, but it is unlikely to produce truly modern object-oriented code; furthermore, any errors that are discovered during testing are buried in the millions of lines of generated code with which no engineer is remotely familiar. A toolchain approach adds a human element at set points in the overall process balancing these concerns and empowering the engineer to deliver results.
Finally, a legacy process needs to be incremental. Big Bang approaches are often risky for a number of reasons: they don’t allow for any user acceptance testing until the end of the project when it may be too late; they lengthen the process to such a length that it is unlikely to survive the changing priorities of multiple budget cycles; or they allow problems and delays to accumulate to such an extent that the project becomes unviable in terms of time or money. An incremental approach can solve or reduce many of these problems. It’s also important to note that incremental also means separating modernization and improvement. Projects are much more likely to succeed if they focus first on a like-for-like transformation of the application and then add functionality to the modernized product later than if they try to add functionality during the modernization.
At Blu Age we’ve created a modernization factory that incorporates these key DevOps concepts. If you visit our Plano, Texas delivery center you will find teams of highly skilled experts in an open office utilizing cutting-edge tooling to deliver fully Digital applications faster and less expensively than with a traditional rewrite. Free from runtimes or dependencies, and free from legacy code, the legacy applications Blu Age modernizes are ready for the modern digital world, whether that means web, cloud, mobile, or otherwise.
If you would like more information about the Blu Age process, or our technology in general, please let us know.]