CDD – the glue for cloud and legacy apps

One of the biggest problems businesses have with the cloud is the disconnect that exists between what they can achieve with new front-end applications and services delivered via the cloud, and the legacy back-end business management tools that are used to run the business. These legacy apps are often excellent at what they do, and achieve results consistently and reliably. But they are, for a variety of reasons, unchangeable.

Yet now they exist in a world of rapid change, and the businesses themselves have a growing need for those applications to co-exist with the change – and they can’t. What is worse is that the bigger and more established the enterprise, the greater the chance that this problem exists, and the greater its impact on the business itself.

Finding a way of bringing those legacy applications into the new, cloud-oriented environment is essential, yet as proved to be extremely difficult. With some of these applications it has been possible upgrade to `cloud versions’, but that can be a limited solution only, as many businesses then want to extend and adapt those legacy apps to collaborate and participate with cloud apps rather than just interface with them.   

With other legacy apps even that is a luxury, for the source code is lost, the developers are all dead and no-one now knows the programming language. They also run long-obsolete hardware with long-forgotten operating systems. Yet work they do, and their work is usually extremely critical. The only current hope these business have is that they keep working.

Finding a way round this problem has been the target for Martin Rice and Philip Rice. The pair first started down this road with the first iteration of a company called Erudine, but their approach – though effective - was seen by potential customers as too costly. The pair, however, rethought the fundamentals of what they were trying to achieve and the result is now ready to roll in significantly different form, delivered by their new business, The Agile Consultancy.

They have come up with an open source approach to the issue of migrating legacy applications, and in particular those often intransigent, large, undocumented, aged but still extremely important applications to be found in large enterprises. It is an approach that bypasses the legal problems that can come with attempting to reverse engineer legacy code, while at the same time creates a new implementation of the functionality the original applications perform, transformed for use in any way that the enterprise then requires it.

Given the growing importance of the cloud as a delivery vehicle for enterprise applications, this transformation very definitely includes the availability of that legacy functionality for delivery as cloud services.

The approach taken by The Agile Consultancy is known as Constraint Driven Development (CDD). This is a development from Test Driven Development models that adds the constraint `because’. As Martin Rice, the business half of the partnership, explains, “All processes can be considered as a `white box’ that transforms inputs into required outputs.”

This means that any legacy application has within it the test sequences required to define whether any recreation of its processes have passed or failed. In practice, therefore, the CDD model can be used to build a functional simulation of a legacy application – or for that matter an entirely new-build application – by refining code until the same inputs as used by the original application consistently produce the same outputs.

“The goal is to consistently achieve zero errors between the original application and the simulation,” Rice said, “and if there is an error the developer knows where work is still required.”

The result is a working clone of the original application, but this time available running in a Java Virtual Machine that can be ported and run on a wide range of different platforms and environments. It is also fully documented, which means it can be understood, adapted, extended or otherwise modified in future as required. And because it is written in Java and is open sourced, it can be readily integrated with other applications by other developers.

“Many enterprises have applications, and some of them are mission critical to the business, running on platforms that they have to get off. They are being forced to because that platform is no longer supported, or there is no one left working that really understands it any more. So the ability to recreate that application’s full functionality in a Java VM can give them total flexibility on how they move forward, because they can now move forward.”

This is particularly relevant to some areas of the financial community, where there are still seriously mission critical, but now extremely old, applications that run on ancient machines from the likes of long-gone Digital Equipment Corp. The applications are written in rarely used programming languages and are poorly documented, so maintenance is a problem, and no one has the skills to update them or make adaptations that would be valuable to the business now.

“What CDD can offer is a way to build a fully functional clone of the original application that works with all the inputs and produces all the right outputs,” Rice said. “Not only that it, can also clone the required operational methods for user compatibility. If the users work on green-screen terminals there is no point in giving them a fancy graphical interface, because they won’t know how to work it.”

And it is that combination of known factors: the known inputs, the known outputs required, and the known operational requirements, that form the test process that has to be gone through. Only when there is a consistent result of zero errors – which can be tested for as long as the customer requires by simply running the original application and the clone in parallel – can the clone be signed off as the new application.

“Only then do the real advantages of this process come into play for the business,” he said. “Once the application is available as a fully documented JavaVM they can start considering how they might want to change it or adapt it to meet changes in their business patterns. They can, for example, then turn a legacy batch program, many of which only run once a day overnight, into an online, on demand, real time service.”

This latter capability could prove to be of immense value all by itself. As cloud services develop, and in particular as they join together with smartphones and tablets as the front-end of increasingly interactive applications, the link between those front-end applications and the back-end business management systems gets shorter and faster. The need to get interaction between them in near real-time itself becomes business critical. Waiting for an overnight batch program to run will increasingly be seriously detrimental to future business.

Yet the biggest risks so far for such businesses have been the problem that those back-end batch programs work and work well while the costs, time and risk of failure involved in attempting to build a new real-time version from the ground up are considered too great. The CDD approach would seem to provide a solution to this real problem.

What is more, there is not too much of a skills issue with CDD, unlike working with arcane programming languages where the majority of practitioners are either retired or deceased. The skillset is a knowledge of Java, agile programming methods the Scala programming language and Test-Driven Development methods. These are widely known within the open source community.

And being an open source project – the code is available free on GitHub, for example – Rice is very open to the idea that other businesses will take up CDD and add other tools and services around it to extend its usability.

For example, he sees it being a good contributor to the growing service aggregation community, allowing service providers to pull together legacy and new-build applications to create highly granular and focused services for end user businesses. This would also bring with it the advantage of increasing re-usability of the code already created.