Legacy systems are a core asset at many organizations. These legacy systems have been around for decades and have a very critical impact on day to day business processes. However, owing to a variety of reasons, these legacy systems have high TCO and represent a bottleneck towards the emergence of an agile IT portfolio. In this article we'll focus on a variety of options that may be available for the seamless integration of legacy systems with an enterprise IT portfolio. We converge on legacy enablement using Web services as a viable option towards achieving an integrated, agile architecture that leverages open standards for communicating with legacy systems. We also evaluate alternative options of legacy integration and identify tools that may be used to simplify integration with legacy systems.

Overview and Pain Points of Legacy Systems
At the core of many application portfolios there are legacy information systems to support critical business processes. A legacy system can be defined as "a computer system or application program that continues to be used because of the prohibitive cost of replacing or redesigning it, despite its poor competitiveness and compatibility with modern equivalents." These are typically invaluable assets with embedded business logic representing many years of coding, developments, enhancements, and modifications. However, they are often undocumented, tightly coupled, and relatively closed and inflexible. In most cases they were developed independently without a consistent underlying architecture, resulting in overlapping and redundant functionality and data. The main pain points presented by legacy assets can be summarized as follows:

• High cost of ownership, including costs of maintenance, operation, and upgrade of both software and hardware; for example, CPU usage-based pricing for mainframes.
• High time to market because of complex and poorly understood code. This may prevent the system from satisfying the evolving business requirements because simple changes take too long to complete and test. Changes tend to cause significant ripple effects, and require more regression testing. This in turn increases maintenance and evolution costs.
• Monolithic architecture with little or no modularity together with redundant code. This is usually related to extensive patches and modifications as well as duplicated/similar functionality implemented in different systems by separate teams.
• Closed and outdated technology that is difficult to integrate and interface with new open technologies and modern distributed architectures.
• Shrinking talent pool of developers skilled in legacy systems and decreasing vendor support. Knowledge of these systems is usually restricted to a core set of people who are difficult to replace.
• Lack of application knowledge due to the departure of original developers or users as well as missing or obsolete documentation.

The important point to note is that legacy systems satisfy mission-critical operations and have been doing so for most large organizations for a long time. In addition, legacy systems have enjoyed significant investment from the IT organizations. Therefore, it needs to be noted that despite their shortcomings as illustrated above, it is not viable to replace an entire system; it requires careful planning and appropriate migration support. Rewriting all of the legacy applications and migrating data involves high cost and enormous complications. However, the burden of maintaining and extending legacy systems that are increasingly cut off from current technology compels the need for a planned and phased migration from legacy systems towards a more agile, IT architecture.

Options for Handling Legacy Systems
Research efforts and commercial providers have proposed various approaches to address the pain points of legacy systems. However, the major problem remains: the identification of useful legacy functionality that can be exposed for collaborating applications at an optimal level of granularity. Additionally it is important to estimate and analyze the consequences of service-enablement decisions on the system-quality attributes (such as performance and maintainability) and the solution cost. In this regard, a systematic and comprehensive method to guide the transformation and integration of legacy applications with an enterprise-level architecture such as service-oriented architecture (SOA) is currently lacking. SOA using Web services is gaining acceptance as the primary mechanism to interconnect disparate applications and ease interoperability between heterogeneous systems for internal as well as external integration. It promises improved business agility and reduced integration costs through increased interoperability and reuse of shared business services. One of the key obstacles to realizing this vision is the service enablement of existing legacy applications to collaborate in an enterprise-wide SOA. Over the past few years, significant advancements have been made to modernize and improve the interoperability of legacy systems. Figure 1 depicts our classification of existing approaches.

Legacy modernization approaches can be divided into two broad categories:

• Legacy integration and service enablement is a tactical approach to align legacy systems to business needs through noninvasive wrapping of legacy assets by using new layers of flexible technologies such as EAI solutions and messaging tools, and recently with standardized interfaces using Web services.
• Legacy transformation is a strategic approach that aims to revitalize and streamline legacy systems to ease maintenance and extensions through invasive reengineering to augment the legacy systems architecture. It involves a deep and detailed analysis of the existing code base, and an understanding of the system functionality and data architecture. Subsequently, it involves the extraction and rationalization of data definitions, data, and business rules. This is followed by an iterative process that involves refactoring, consolidation, componentization, and redesigning activities to make the code more modular and to ease the incremental migration to a flexible architecture. Figure 2 illustrates the various classes of options available for legacy modernization.

Clearly, the option on the bottom left, that is, "Legacy Wrapping/Service Enablement" can prove to be a very prudent short-term solution because it promises quick turnaround and minimal changes to the existing legacy platform. The rest of this article focuses on this approach and discusses various options to perform this integration.

Options for Legacy Enablement
Legacy integration aims to revitalize and extend the reach and lifetime of legacy systems by exposing existing functionality through the use of wrapping. It adds a front-end software layer to hide unwanted complexity and exposes modern interfaces to ease interoperability. The options for integrating legacy systems are:

• User-interface wrapping or screen scraping, where legacy screens are mapped into modern graphical or Web service interfaces. Advances in the capabilities of Web-based, screen-scraping products make development of these interfaces easier with nominal development effort. However, this option makes sense only for applications that are user-interface intensive.
• Data wrapping, where new interfaces are developed for the legacy data structures to allow direct access using standard SQL or XML technologies.
• Business-logic wrapping, where legacy functionalities are wrapped and programmatically accessed through custom object-oriented wrappers, EAI adapters, or Web services interfaces.

Legacy wrapping requires less up-front architecture and design, and it can reduce integration costs and provide a roadmap to incrementally reengineer and transfer legacy components to a new platform without having to go through a "big bang" type of replacement of the system. However, legacy wrapping can only provide a tactical, short-term solution because it addresses the integration and flexibility pain points without impacting the source code significantly. True flexibility will be achieved only by understanding the legacy source code repository and refactoring it to some extent.