Download this report for insight into a new class of online technology innovations that fosters quick development of new cloud-based software and modernization of business-critical legacy systems. Also featured in this report: essential guidelines from Technology Evaluation Centers for overcoming the challenges of software development, and a detailed checklist for vetting a system’s ability to adapt to good software development practices.
There may be no IT issue more compelling for today’s businesses than cloud computing. IT executives interviewed by Gartner called it their top technology imperative for 2011.
The shift to the cloud is inevitable, and most organizations will move toward a mix of private (in-house) and public (remote) clouds. The key difference between the two is that you build a private cloud, but you buy a public cloud (with the caveat that access to the public cloud should only be granted to trusted users—if you do it right, a public cloud is just as private as a private cloud). On the private side, organizations are halfway there if they’ve already virtualized their servers. Once they take that step, they need to ensure that these virtual machines are flexible, taking advantage of extra resources as they’re needed and creating a view of business software as a unified manageable set of services.
As a second step toward a comprehensive cloud-based offering, organizations need to quickly develop new cloud-based software and modernize any software based on older technologies and hardware that continues to provide core services. Many old desktop applications, for example, are built from a variety of generic technologies, such as client-server applications, spreadsheets, and database management systems. The industry is currently overflowing with millions of such applications that are reaching the end of their life cycle.
These legacy applications, like other intangible assets, are hard to emulate by competitors, which is why they represent key differentiators and a source of competitive advantage. Typically, a significant investment in intellectual capital has been made in legacy systems over time.
Indeed, not all systems need to be modernized, and specific systems that are only used by a few employees are not good candidates. On the other hand, there are two important reasons to convert old and secluded systems to the Web:
Business justification: Stakeholders are requesting it since they know that enterprise integration (EI) and business-to-business integration (B2BI) are best achieved through distributed business processes securely accessed through an intranet or the Internet.
Technology justification: Business objectives are best achieved with modern IT technology strategies.
Another reason for modernizing these systems stems from the fact that desktop applications are prone to growth and increasing complexity over time. An application that started as a simple low-scale prototype can grow to a critical business application that supports tens and sometime hundreds of users!
To stay current with business needs, legacy applications must be quickly recycled into a modern format. Moreover, many corporations recognize the need to renew legacy mainframe applications in order to provide a Web interface and improve interconnections with customers and partners.
However, new software development and modernization projects are taking too many development and QA cycles. Poor time-to-market combined with prohibitive development costs are slowing down most organizations.
Is there a way to greatly reduce these business pains in order to leverage the cloud’s efficiencies—from both an economic and operational perspective?
Software Modernization Using Conventional Methods
Once organizations get a feel for which legacy software needs to be modernized, they must evaluate the most cost-effective methods for doing this. Traditionally, there are three strategies for introducing distributed-object concepts into existing legacy software systems:
1. Start from scratch: Redevelop the business applications with distributed object concepts. This approach frees developers from any consideration of existing systems. However, every function must be implemented and tested in a new language and a new environment, which is expensive and time consuming.
2. The reengineering approach: Engineers convert the programs of existing systems to object-oriented programs, and distribute objects appropriately. This approach is promising since it is not necessary to implement functionalities that already exist. However, code conversion is not easy.
3. Wrap components of the existing systems and invoke them from the distributed object-oriented environment: Wrapping is a method of encapsulation that provides clients with modern interfaces for accessing server applications or components. This approach is recommended for large mainframe legacy systems; in the case of a 20-million line system, it’s impossible to rewrite all the code manually without making mistakes. And even just a few mistakes can have a large effect on your organization’s business operations.
When all is said and done, various conventional methods and techniques can be used to renew a system, but in many cases these approaches rely on costly manual development operations.
As for outsourcing, studies show that although it looks affordable, it’s not easy to have modern software built thousands of miles away. Outsourcing is great when the level of service complexity is low, which is not the case for the development of complex data management software.
Cost savings achieved from outsourcing software development and testing can be more than offset by the business cost of frustrated customers and users due to poor quality software and delayed projects. Nearshoring, however, offers the following benefits: fewer time zone differences, geographical proximity, and more cultural/language similarities.
To be successful in Web-based software development, you need a high-productivity agile development process to support a proficient near-shoring service model that competes favorably against overseas outsourcing.