Mainframe Migration based on Screen Scraping

Companies possess a history and large array of legacy information systems that consume a great part of their IT budget in operations and maintenance. These systems are mission-critical, and they cannot be fully discarded since they retain business rules and provide information that is not available anywhere else. Unfortunately, decades-old legacy systems cannot easily withstand modification. Mainframes specifically conglomerate most of these legacy systems. Although there are some white-box solutions for migrating mainframe systems, such solutions lack systematicity and do not provide mechanisms for verifying business rules preservation. Hence, this paper presents a black-box solution (ignoring the internal structure of COBOL programs) which uses a screen scraping technique for migrating mainframe systems toward JavaFX and relational databases. Together with this solution, this paper provides an automatic verification technique to check if the recreated system reflects all the embedded business logic. This proposal has been designed and developed in the context of an industrial project, in which the solution has already migrated 43,000,000 mainframe screens from four systems. The main implication for researchers and practitioners is that screen scraping has proved to be feasible for migrating mainframe systems in large-scale projects within a manageable time-frame while preserving business

Soft policies and hard competition: Government, industry, and user impacts on the development of Japan's software industry

The paper analyzes the development and structure of the Japan's software industry, focusing particular attention on the failure of government support policies to nurture an internationally competitive industry and the success of foreign software producers in the Japanese market. The research adopts an evolutionary approach to explain Japan's problems in building a competitive software industry except in games, challenging the validity of standard explanations such as cultural disadvantage and failure to adopt best practice. The pattern of development in the Japanese software industry results from strong user preference for customized software over packaged products. Large users develop highly customized software systems that reflect their unique organizational structures and operating advantages. Software is viewed as an input into the production process, rather than an output to be independently marketted. As such, the structure of the software reflects the administrative heritage of major industrial users as much as developments in computer technology. The tendency to emphasize customization favors intra-industry software advances over interindustry expansion. Moreover, high demand for customization combines with large variation in operating systems to fractionalize the industry and frustrate government support policies. Even though the Ministry of International Trade and Industry followed the same industry support model that proved so successful in manufacturing, an independent world class software industry has not developed. The preference for customization has also allowed foreign software producers to successfully pursue a hub and spoke strategy. Foreign producers have been able to expand their user base, thereby lowering unit cost and putting local software developers at a further disadvantage. The research suggests that this situation will continue

A Model for Transforming Legacy Systems in a client/Server Environment Based on the Unified Modeling Language(UML)

In this dissertation the researcher developed the methodology for the migration of computer programs from a legacy architecture to client/server architecture. System migrations have failed frequently, and even so-called successful migrations may have serious usability problems. Additional difficulties include missing documentation of the existing program(s), the persons who developed the existing system are not available for consultation, and, frequently, there are important operational and economic issues that must be considered. The client/server environment is quite different from the source environment; the operating system and implementation languages have changed, and system requirements may have been greatly expanded, frequently including the Internet. User interface equipment and techniques are more comprehensive, system response times may be more demanding, significant software system components may be purchased instead of developed in-house, and other elements of the operating theater may be either entirely new or greatly revised. The methodology for developing systems has evolved significantly. In order to make use of the advantages of client/server equipment, new concepts will need to be embodied in the migrated program, such as the use of middleware, object technology to permit the development of higher quality software, and the separation of functionality into server-side and client-side procedures. This dissertation identifies those factors that most critically affect the possibility of success or of failure in the migration. These factors will make it possible to lessen or eliminate the potential for failure. In addition, this dissertation will provide a model for the conversion of legacy systems to more reliable and scalable client/server systems. For this dissertation, the researcher gathered published material relating to the migration of computer systems from one hardware/software platform to a second. Some of the material discussed the conversion process itself. Other material described successes, failures, general techniques and approaches to the migration. Still others discussed nontechnical aspects, including the creation of migration teams and user training. From this material, the most pertinent factors were identified, and from them, a plan of success was developed. That plan of success is this dissertation

In the Beginning... A Legacy of Computing at Marshall University

This book provides a brief history of the early computing technology at Marshall University, Huntington, W.Va., in the forty years: 1959-1999. This was before the move to Intel and Windows based servers. After installation of an IBM Accounting Machine in 1959, which arguably does not fit the modern definition of a computer, the first true computer arrived in 1963 and was installed in a room below the Registrar’s office. For the next twenty years several departments ordered their own midrange standalone systems to fit their individual departmental requirements. These represented different platforms from different vendors, and were not connected to each other. At the same time, the Marshall Computer Center developed an interconnected, multi-processor environment. With the software problems of year 2000, and the I/T move to the new Drinko Library, several systems were scrapped. New systems were installed on the pc server platforms. This book includes images of the various systems, several comments from users, and hardware and software descriptions

Design Information Recovery from Legacy System COBOL Source Code: Research on a Reverse Engineering Methodology

Much of the software in the world today was developed from the mid-1960s to the mid- 1970s.This legacy software deteriorates as it is modified to satisfy new organizational requirements. Currently, legacy system maintenance requires more time than new system development. Eventually, legacy systems must be replaced. Identifying their functionality is a critical part of the replacement effort. Recovering functions from source code is difficult because the domain knowledge used to develop the system is not routinely retained. The source code is frequently the only reliable source of functional information. This dissertation describes functional process information recovery from COBOL source code in the military logistics system domain. The methodology was developed as an information processing application. Conceptual and logical models to convert source code to functional design information were created to define the process. A supporting data structure was also developed. The process reverse engineering methodology was manually applied to a test case to demonstrate feasibility, practicality, and usefulness. Metrics for predicting the time required were developed and analyzed based on the results of the test case. The methodology was found to be effective in recovering functional process information from source code. A prototype program information database was developed and implemented to aid in data collection and manipulation; it also supported the process of preparing program structure models. Recommendations for further research include applying the methodology. to a larger test case to validate findings and extending it to include a comparable data reverse engineering procedure

Building a Systematic Legacy System Modernization Approach

A systematic legacy system modernizing approach represents a new approach for modernizing legacy systems. Systematic legacy system modernization has software reuse as an integral part of modernization. We have developed a modernization approach which uses software architecture reconstruction to find reusable components within the legacy system. The practice of software development and modernization continues to shift towards the reuse of components from legacy systems to handle the complexities of software development. Modernization of a legacy system requires reuse of software artefacts from legacy system to conserve the business rules and improve the system’s quality attributes. Software reuse is an integral part of our systematic legacy modernization approach. Software should be considered as an asset and reuse of these assets is essential to increase the return on the development costs. Software reuse ranges from reuse of ideas to algorithms to any documents that are created during the software development life cycle. Software reuse has many potential benefits which include increased software quality, and decreased software development cost and time. Demands for lower software production and maintenance costs, faster delivery of systems and increased quality can only be met by widespread and systematic software reuse. In spite of all these benefits software reuse adoption is not widespread in the software development communities. Software reuse cannot possibly become an engineering discipline so long as issues and concerns have not been clearly understood and dealt with. We have conducted two surveys to understand the issues and concerns of software reuse in the Conventional Software Engineering (CSE) Community and the Software Product Line (SPL) Community where reuse is an integral part of the product development. The quantitative and qualitative analysis of our surveys identified the critical factors which affect and inhibit software engineers and developers adopting software reuse. Software reuse has been talked about in generic terms in software product lines. Though software reuse is a core concept in SPL it has however failed to become a standardized practice. The survey conducted on the SPL Community investigates how software reuse is adopted in SPL so as to provide the necessary degree of support for engineering software product line applications and to identify some of the issues and concerns in software reuse. The identified issues and concerns have helped us to understand the difference between software reuse in the CSE and SPL Communities. It has also given us an indication of how both communities can learn good software reuse practices from each other in order to develop a common software reuse process. Based on the outcome of our surveys we have developed a systematic software reuse process, called the Knowledge Based Software Reuse (KBSR) Process, which incorporates a Repository of reusable software assets to build a systematic legacy system modernization approach. Being able to reuse software artefacts, be it software requirement specification, design, or code, would greatly enhance software productivity and reliability. All of these software artefacts can go in the Knowledge Based Software Reuse Repository and be candidates for reuse

Evolution of batch-oriented COBOL systems into object-oriented systems through unified modelling language.

Throughout the world, there are many legacy systems that fulfil critical business functions but often require new functionality to comply with new business rules or require redeployment to another platform. Legacy systems vary tremendously in size, functionality, type (such as batch-oriented or real-time), programming language source code, and many other factors. Furthermore, many of these legacy systems have missing or obsolete documentation which makes it difficult for developers to re-develop the system to meet any new functionality. Moreover, the high cost of whole scale redevelopment and high switchover costs preclude any replacement systems for these legacy systems. Reengineering is often proposed as a solution to this dilemma of high re-development and switchover costs. However, reengineering a legacy system often entails restructuring and re-documenting a system. Once these restructuring and re-documentation processes have been completed, the developers are better able to redevelop the parts of the systems that are required to meet any new functionality. This thesis introduces a number of methods to restructure a procedurally-structured, batch-oriented COBOL system into an object-oriented, event-driven system through the use of an intermediate mathematical language, the Wide Spectrum Language (WSL), using system source code as the only documentation artefact. This restructuring process is accomplished through the application of several algorithms of object identification, independent task evaluation, and event identification that are provided in the thesis. Once these transformations are complete, method(s) are specified to extract a series of UML diagrams from this code in order to provide documentation of this system. This thesis outlines which of the UML diagrams, as specified in the UML Specifications version 1.5, can be extracted using the specified methods and under what conditions this extraction, using system source code only, can occur in a batch-oriented system. These UML diagrams are first expressed through a WSL-UML notation; a notation which follows the semantics and structure of UML Specifications version 1.5 in order to ensure compatibility with UML but is written as an extension of WSL in order to enable WSL to represent abstract modelling concepts and diagrams. This WSL-UML notation is then imported into a visual UML diagramming tool for the generation of UML diagrams to represent this system. The variety of legacy systems precludes any universal approach to reengineering. Even if a legacy system shares a common programming language, such as COBOL, the large number of COBOL constructs and the huge number of possible dialects prevents any universal translator of the original program code to another. It is hoped that by focusing on one particular type of legacy system with constraints, in this case a batch-oriented COBOL system with its source code its only surviving artefact, and by providing validated algorithms to restructure and re-document these legacy systems in the Unified Modelling Language, an industry system modelling standard, and by determining which of these Unified Modelling Language can be extracted practically from such a system, some of the parameters and uncertainties, such as program understanding of an undocumented system, in reengineering this type of system can be reduced