COBOL Programs Research Articles

Software modernization powered by dynamic language product lines

Legacy software poses a critical challenge for organizations due to the costs of maintaining and modernizing outdated systems, as well as the scarcity of experts in aging programming languages. The issue extends beyond commercial applications, affecting public administration, as exemplified by the urgent need for COBOL programmers during the COVID-19 pandemic. In response, this work introduces a modernization approach based on dynamic language product lines, a subset of dynamic software product lines. This approach leverages open language implementations and dynamically generated micro-languages for the incremental migration of legacy systems to modern technologies. The language can be reconfigured at runtime to adapt to the execution of either legacy or modern code, and to generate a compatibility layer between the data types handled by the two languages. Through this process, the costs of modernizing legacy systems can be spread across several iterations, as developers can replace legacy code incrementally, with legacy and modern code coexisting until a complete refactoring is possible. By moving the overhead of making legacy and modern features work together in a hybrid system from the system implementation to the language implementation, the quality of the system itself does not degrade due to the introduction of glue code. To demonstrate the practical applicability of this approach, we present a case study on a COBOL system migration to Java. Using the Neverlang language workbench to create modular and reconfigurable language implementations, both the COBOL interpreter and the application evolve to spread the development effort across several iterations. Through this study, this work presents a viable solution for organizations dealing with the complexity of modernizing legacy software to contemporary technologies. The contributions of this work are (i) a language-oriented, incremental refactoring process for legacy systems, (ii) a concrete application of open language implementations, and (iii) a general template for the implementation of interoperability between languages in hybrid systems.

Mining Association Rules from Code (MARC) to support legacy software management

This paper presents a methodology for Mining Association Rules from Code (MARC), aiming at capturing program structure, facilitating system understanding and supporting software management. MARC groups program entities (paragraphs or statements) based on similarities, such as variable use, data types and procedure calls. It comprises three stages: code parsing/analysis, association rule mining and rule grouping. Code is parsed to populate a database with records and respective attributes. Association rules are then extracted from this database and subsequently processed to abstract programs into groups containing interrelated entities. Entities are then grouped together if their attributes participate to common rules. This abstraction is performed at the program level or even the paragraph level, in contrast to other approaches that work at the system level. Groups can then be visualised as collections of interrelated entities. The methodology was evaluated using real-life COBOL programs. Results showed that the methodology facilitates program comprehension by using source code only, where domain knowledge and documentation are either unavailable or unreliable.

Extracting Business Rule from existing COBOL programs for Redevelopment

The paper describes an industrial business study carried out to regain the business knowledge embedded in a legacy COBOL application. The aim of this work was to extract out the information required to re- implement the Legacy programs in a new client/server environment. The progress solution is in four step. Firstly, the programs were restructured, secondly the programs were sliced into business logic modules, third the business modules were subjected to a multi view analysis and finally the views were integrated into a unified documentation describing the data, decision and procedural flow of each program slice.

COBOL Systems Migration to SOA: Assessing Antipatterns and Complexity

SOA and Web Services allow users to easily expose business functions to build larger distributed systems. However, legacy systems –mostly in COBOL– are left aside unless applying a migration approach. Main approaches are: direct and indirect migration. The former implies to wrap COBOL programs with a thin layer of a Web Service oriented language/platform. The latter needs reengineering COBOL functions to a modern language/platform. In a previous work, we presented an intermediate approach based on direct migration where developed Web Services are later refactored to improve their interfaces quality. Refactorings mainly capture good practices inherent to indirect migration. For this, antipatterns for WSDL documents (common bad practices) are detected to prevent issues related to WSDLs understanding and discoverability. In this paper, we assess antipatterns of Web Services’ WSDL documents generated upon the three migration approaches. In addition, generated Web Services’ interfaces are measured in complexity to attend both comprehension and interoperability. We apply a metric suite (by Baski & Misra) to measure complexity on services interfaces – i.e., WSDL documents. Migrations of two real COBOL systems upon the three approaches were assessed on antipatterns evidences and the complexity level of the generated WSDL documents.

A Debate over the Teaching of a Legacy Programming Language in an Information Technology (IT) Program

This paper presents a debate between two faculty members regarding the teaching of the legacy programming course (COBOL) in a Computer Science (CS) program. Among the two faculty members, one calls for the continuation of teaching this language and the other calls for replacing it with another modern language. Although CS programs are notorious for continuous updates (and hence debates over the updates) of their courses, but the teaching of COBOL programming language has sparked many debates that have been on-going for years. Each side of the debate provides evidences that support their position. This study, although, provides a debate over the same topic but it is different from ongoing debates because it balances the views expressed by both sides of the debates. This in turn shows the difficulty encountered by various departments when making a decision about COBOL. We are presenting in the paper a thorough literature review regarding both sides of views. We are also incorporating in this debate the lessons we learned from our long experience in this field. Thus, we will present our conclusion and recommendation in this paper based on the literature review and on our experience in this field. Our goal from writing this paper is two faceted: first, to present opinions about each side of the position regarding the teaching of COBOL, and, second, to reach a consensus regarding the continuation of teaching this programming language (or for this matter replacing it with another language).

MAINFRAME TO ENTERPRISE TO THE IS CURRICULUM

Over the decades the concept of a mainframe has been synonymous to IBM operating systems and the COBOL programming language. While object-orientated programming languages, web interface transaction systems, web services, distributed services, and mobile application topics are frequently included in the IS/CS curriculum, this paper considers the inclusion of IBM Enterprise Systems. IBM zEnterprise has evolved into an integrated, scalable, enterprise system which supports legacy applications, open-source applications and tools, DB2, Cognos, SPSS, data mining and Rational project management tools. The growth and market penetration of IBM zEnterprise has been spectacular. This evolution of IBM Enterprise Systems provides many opportunities for IS/CS majors. A case study implementing the IBM Academic Initiative in an ABET-CAC curriculum is presented.

A pilot project for migrating COBOL code to web services

This paper describes a pilot project conducted to test the feasibility of constructing web services from existing mainframe COBOL programs. The project involved the use of four tools. The first tool, COBAudit, was intended to identify candidates for web services. The second tool, COBStrip, served to extract only that portion of the code required to fulfill the service. The third tool, COBWrap, wrapped the code extracted from original code and converted it to an executable component. The fourth tool, COBLink, connected the wrapped component to the web by generating a WSDL interface from either the COBOL linkage section or the original map definition. The tools were applied to a legacy life insurance system with more than 20 million lines of COBOL code running under IMS on the IBM mainframe.

Goto elimination in program algebra

This paper shows that program algebra (PGA) [J.A. Bergstra, M.E. Loots, Program algebra for sequential code, J. Logic Algebraic Programm. 51 (2002) 125–156] offers a mathematical and systematic framework for reasoning about correctness and equivalence of algorithms and transformation rules for goto removal. We study correctness and equivalence for the algorithm proposed by Cooper for goto elimination with additional boolean variables. To remove goto statements without the use of additional variables, we propose a technique to get rid of head-to-head crossings and subsequently employ the results of Peterson et al. and Ramshaw. Finally, we provide formal correctness proofs in the setting of PGA for industrial transformation rules given recently by Veerman for restructuring Cobol programs in real-life applications. We hereby show that PGA can explain goto elimination with mathematical rigor to a larger public.

Evaluating legacy system migration technologies through empirical studies

We present two controlled experiments conducted with master students and practitioners and a case study conducted with practitioners to evaluate the use of MELIS (Migration Environment for Legacy Information Systems) for the migration of legacy COBOL programs to the web. MELIS has been developed as an Eclipse plug-in within a technology transfer project conducted with a small software company [16]. The partner company has developed and marketed in the last 30 years several COBOL systems that need to be migrated to the web, due to the increasing requests of the customers. The goal of the technology transfer project was to define a systematic migration strategy and the supporting tools to migrate these COBOL systems to the web and make the partner company an owner of the developed technology. The goal of the controlled experiments and case study was to evaluate the effectiveness of introducing MELIS in the partner company and compare it with traditional software development environments. The results of the overall experimentation show that the use of MELIS increases the productivity and reduces the gap between novice and expert software engineers.

Review of "COBOL Programmers Swing With Java by E. Reed Doke, Bill C. Hardgrave and Richard A. Johnson", Cambridge University Press, 2005

No abstract available.

Source model analysis using the JJTraveler visitor combinator framework

AbstractProgram understanding tools manipulate program representations, such as abstract syntax trees, control‐flow graphs, or data‐flow graphs. This paper deals with the use of visitor combinators to conduct such manipulations. Visitor combinators are an extension of the well‐known visitor design pattern. They are small, reusable classes that carry out specific visiting steps. They can be composed in different constellations to build more complex visitors. We evaluate the expressiveness, reusability, ease of development, and applicability of visitor combinators to the construction of program understanding tools. To that end, we conduct a case study in the use of visitor combinators for control‐flow analysis and visualization as used in a commercial Cobol program understanding tool. Copyright © 2004 John Wiley & Sons, Ltd.

Revitalizing modifiability of legacy assets

AbstractThe modifiability of Cobol legacy code is discussed and an approach is proposed to improve the modifiability using automatic restructuring transformations. An algorithm is presented that enables the application of these transformations to large industrial Cobol systems. The transformations were adapted to a system of 80 000 lines of code by extending them with new transformations and transformation patterns. The resulting source code is analysed and discussed. Two case studies (over 5 million lines of code in total) with real‐life Cobol programs show the large‐scale application of the transformations. Copyright © 2004 John Wiley & Sons, Ltd.

Learning program organization through COBOL

Arguably, many computer languages have more panache and less verbosity than COBOL; but none has greater potential to inculcate the habits and techniques of <u>advance</u> planning for such things as structure, the byte-length of variables representing the results of computations, table/array size, fields that will be needed, and the like. To illuminate a program's logic one can add some judiciously chosen, even un-required, yet available reserved words. I have found that the COBOL language aids and encourages comprehension of logical structure to a greater degree than with other languages. Moreover, in COBOL, meaningful, if lengthy, names are actually desirable and serve to clarify the work that takes place in the various procedures. Finally, because the structure of a COBOL program is so determinate, it is possible to teach a series of steps leading up to the end product, which both foreshadow and greatly organize the process of coding. This habit of organization is easily transferable to other contexts.

The microarchitecture of the IBM eServer z900 processor

The recent IBM ESA/390 CMOS line of processors, from 1997 to 1999, consisted of the G4, G5, and G6 processors. The architecture they implemented lacked 64-bit addressability and had only a limited set of 64-bit arithmetic instructions. The processors also lacked data and instruction bandwidth, since they utilized a unified cache. The branch performance was good, but there were delays due to conflicts in searching and writing the branch target buffer. Also, the hardware data compression and decimal arithmetic performance, though good, was in demand by database and COBOL programmers. Most of the performance concerns regarding prior processors were due to area constraints. Recent technology advances have increased the circuit density by 50 percent over that of the G6 processor. This has allowed the design of several performance-critical areas to be revisited. The end result of these efforts is the IBM eServer z900 processor, which is the first high-end processor based on the new 64-bit z/Architecture™.

Preface: Volume 59, Issue 4

ForewordThis volume contains the Proceedings of the Second International Workshop on Rule-Based Programming (RULE2001). The Workshop was held in Firenze, Italy on September 4, 2001, as satellite event to PLI2001.This is the second edition of the International Workshop on Rule-Based Programming (RULE'2001). We aim with this workshop at a fruitful cross fertilization of the theoretical foundations of rule-based programming with practical applications and implementation of rule-based systems. We are very pleased with the broad range of papers: quite a number of very theoretical ones upto papers describing a system and a paper describing a comparison between a number of rule-based systems to tackle a bio-medical problem.Rule-based programming began with AI rule-based systems in the seventies. This paradigm is inherent in Prolog and has been used in program-manipulation systems like Refine. Indeed, the rewriting concept appears throughout computer science, from its theoretical foundations to very practical implementations. Extreme examples include the mail system in Unix which uses rules in order to rewrite mail addresses to canonical forms and the transition rules describing the behaviour of tree automata. Rewriting is used in semantics in order to describe the meaning of programming languages, as well as in program transformations like the re-engineering of Cobol programs. It is used to compute, implicitly or explicitly, as in Mathematica or OBJ, but also to perform deduction when using inference rules to describe a logic, theorem prover or constraint solver. Last, but not least, this approach is central to systems that raise the notion of rule to an explicit first class object, like expert systems, programming languages based on equational logic, algebraic specifications (e.g. OBJ), functional programming (e.g. ML) and transition systems (e.g. Murphi).Rule-based programming is currently experiencing a renewed period of growth with the emergence of new concepts and systems that allow one to better understand and better use it. From the theoretical side, after the in-depth study of rewriting concepts during the eighties, the nineties saw the emergence of the general concepts of rewriting logic and of the rewriting calculus. On the practical side, new languages, like ASM, ASF+SDF, Claire, ELAN and Maude, systems like LRR, and also commercial products, like Ilog Rules, have shown that the concept of rule could be of major interest as a programming tool. In particular, because it is now of practical use, fundamental questions arise, like the theoretical study of the algorithmic complexity of programs written in such languages, as well as their optimisation. Of course, semantics of such languages, compilation techniques and methodological studies of their use should also be explored.Rule based programming is closely related to both functional programming (when the term rewrite system is confluent and terminating) as well as classical logic programming (when the rewrite system is used for nondeterministic search).Accordingly, the purpose of this workshop is to bring together researchers from these various domains to foster fertilisation between theory and practice, as well as to favour the growth of this programming paradigm. Mark van den Brand(CWI Amsterdam)Iliano Cervesato(ITT Industries)Nachum Dershowitz(Tel-Aviv University)Bernd Fischer(RIACS/NASA Ames, Moffett Field)Claude Kirchner(LORIA Nancy)Jean-Yves Marion(LORIA Nancy)Narciso Marti-Oliet(Universidad Complutense de Madrid)Rakesh M. Verma(University of Houston)Eelco Visser(Utrecht University)This volume will be published as volume 44-2 in the series Electronic Notes in Theoretical Computer Science (ENTCS). This series is published electronically through the facilities of Elsevier Science B.V. and its auspices. The volumes in the ENTCS series can be accessed at the URLWe would like to thank the program committee members for their help in evaluating the papers and making a scientifically interesting selection. Furthermore, we would like to thank the {\\bf PLI} organizing committee for taking care of the local organization of our workshop. We thank the ACM organization for sponsoring this workshop. We thank Elsevier for publishing these proceedings in the Electronic Notes in Theoretical Computer Science (ENTCS). Finally, we thank Professor Michael Mislove for providing and adapting the style files for ENTCS.November, 2001 Mark van den Brand and Rakesh M. Verma

An empirical study into COBOL type inferencing

In a typical COBOL program, the data division consists of 50% of the lines of code. Automatic type inference can help to understand the large collections of variable declarations contained therein, showing how variables are related based on their actual usage. The most problematic aspect of type inference is pollution, the phenomenon that types become too large, and contain variables that intuitively should not belong to the same type. The aim of the paper is to provide empirical evidence for the hypothesis that the use of subtyping is an effective way for dealing with pollution. The main results include a tool set to carry out type inference experiments, a suite of metrics characterizing type inference outcomes, and the experimental observation that only one instance of pollution occurs in the case study conducted.

Verification of Year 2000 conversion rules using the ACL2 theorem prover

The well-publicized Year 2000 problem provides interesting challenges for the remediation of noncompliant code. This paper describes some work done at EDS CIO Services, using the ACL2 theorem prover to formally verify correctness of remediation rules. The rules take into account the possibility of “flag” (non-date) values of date variables. Many of them have been implemented in an in-house tool, COGEN 2000TM, that corrects for noncompliant date-related logic in COBOL programs.

An empirical study of complexity metrics in Cobol programs

Complexity has been used as an important means for exploiting codes to predict or improve program quality and to measure the impact of maintenance costs. Many of the complexity metrics have been known to measure a similar construct of program codes. In revealing the underlying construct of 13 complexity metrics, this study divides the 368 Cobol programs into four classes with respect to the lines of code and then performs factor analysis on optimally scaled complexity metrics. In each factor, a representative metric is identified and then used to predict the remaining metrics. The results show that each class has a slightly different set of metrics in factors and that the representative metric can successfully estimate the remaining metrics in the same factor. The findings indicate high quality estimations in the 12 Halstead software-science metrics by utilizing a McCabe cyclomatic metric at the end of the design phase. In addition, the lines of code are nicely fitted by utilizing each complexity metric as an independent variable. The fitted lines are computed by two methods; least squares (LS) and relative least squares (RLS). The predictive quality of the LS and RLS is revealed to be dependent on the metrics.

Does Cobol Exist?/Cobol versus Java [Point/Counterpoint

At first glance, asking whether Cobol exists might seem like a ploy, a setup for describing how the billions of lines of Cobol in the world are responsible for almost every facet of daily life: from paychecks and utility bills to the entire computer based corporate infrastructure. Yet, although thousands of Cobol programmers are alive and well, keeping the wheels of commerce turning, there is a large contingent in the software world for whom Cobol does not exist. Academia barely teaches it, Java and C programmers ignore it, and many look with disdain both at Cobol and the lowly Cobol programmer toiling away at mundane data processing tasks. The irony is that more than the Java, C, or language-of-the-month programmers, Cobol programmers understand data, and in case you haven't noticed, data is back. Not that data ever went away. It's still the driving force behind most of the applications we write. It's just that the Internet has forced the data issue: how to integrate and move data across platforms, build data warehouses and repositories for data mining and e-commerce, and share data and maintain semantics. These are hard problems; ones that Cobol and Cobol programmers have been wrestling with since the 1960s. Now that we perceive data as being hot, Cobol is taking on a new lustre and even getting a second look, especially given the notoriously poor data handling capabilities of cooler languages such as C, C++, and Java.

Cobol in an object-oriented world: a learning perspective

Although recent Internet, Java, and OO trends threaten Cobol's dominance, industry will continue to need the language and its programmers for development as well as maintenance-especially once OO Cobol becomes an official standard. Thus, Cobol training remains a priority. By leveraging their existing knowledge, Cobol programmers can make a smooth transition to object oriented development and Java programming.