Chapter 17: Further Reading

Annotated Bibliography -- Subprograms and the CALL Statement

The following resources provide deeper exploration of COBOL subprogram design, the CALL statement, parameter-passing mechanisms, and modular programming practices in enterprise COBOL environments. They are organized by category and include brief descriptions to help you select the most relevant materials for your learning goals.

Books

1. Murach's Mainframe COBOL by Mike Murach and Associates (2021 edition)

Murach's covers subprograms with a strongly practical focus, showing how production COBOL applications are structured as a main program that calls multiple subprograms for validation, calculation, and data access. The paired-page format presents the calling program and the called subprogram side by side, making it easy to trace parameter correspondence. The book also covers the JCL considerations for static and dynamic calls, including STEPLIB configuration and the link-edit process.

2. Advanced COBOL for Structured and Object-Oriented Programming by Gary DeWard Brown (Wiley, 3rd Edition, 1998)

Brown's advanced text provides the most thorough treatment of COBOL subprogram design available, covering nested programs, the GLOBAL and EXTERNAL clauses for data sharing, and the INITIAL and COMMON attributes. The discussion of when to use nested programs versus separately compiled subprograms is particularly insightful. The book also addresses inter-language calling (COBOL calling C, Assembler, or PL/I) and the parameter-passing conventions required for cross-language communication.

3. Beginning COBOL for Programmers by Michael Coughlan (Apress, 2014)

Coughlan provides a clear introduction to COBOL subprograms using GnuCOBOL, including BY REFERENCE, BY CONTENT, and BY VALUE parameter passing with worked examples. The coverage is more concise than the mainframe-focused texts, making it a good quick-start guide. The GnuCOBOL examples allow readers to practice subprogram calls on a PC environment, which is particularly helpful for understanding the mechanics before working on the mainframe.

4. The Mythical Man-Month by Frederick P. Brooks Jr. (Addison-Wesley, Anniversary Edition, 1995)

While not a COBOL book, Brooks' classic on software engineering provides essential context for understanding why modular programming matters. His insights about system decomposition, information hiding, and the importance of clean interfaces are directly applicable to COBOL subprogram design. The chapters on conceptual integrity and the surgical team model illuminate the organizational practices that make modular COBOL systems maintainable over decades.

IBM Documentation

5. IBM Enterprise COBOL for z/OS: Programming Guide (IBM Documentation, current edition)

The programming guide provides authoritative coverage of CALL BY REFERENCE, BY CONTENT, and BY VALUE as implemented in Enterprise COBOL, including the precise rules for parameter matching, data description compatibility, and the behavior of each passing mechanism with different data types. The sections on static versus dynamic calls document the compiler options (DYNAM, NODYNAM) and link-edit procedures that control call resolution. Search for "Calling and called programs" in the IBM Documentation portal.

6. IBM Language Environment Programming Guide (IBM Documentation)

Language Environment (LE) is the common runtime foundation for COBOL, PL/I, C, and Assembler programs on z/OS. The LE Programming Guide explains how the runtime manages the call chain, allocates storage for each called program, handles inter-language calls, and processes the GOBACK and STOP RUN statements. Understanding LE is essential for debugging subprogram-related abends (such as S0C4 from parameter mismatches) and for designing programs that call non-COBOL routines.

7. IBM Enterprise COBOL for z/OS: Language Reference (IBM Documentation, current edition)

The language reference provides the formal syntax diagrams and semantic rules for the CALL statement, the CANCEL statement, the PROCEDURE DIVISION USING clause, the LINKAGE SECTION, nested programs, and the INITIAL, COMMON, and GLOBAL clauses. This is the definitive reference when you need to verify syntax details or understand the precise behavior of edge cases such as calling a CANCELed program or nesting programs more than one level deep.

Online Resources

8. GnuCOBOL Programmer's Guide (maintained by the GnuCOBOL community)

GnuCOBOL supports the CALL statement, LINKAGE SECTION, and all three parameter-passing mechanisms. The documentation notes behavioral differences from IBM Enterprise COBOL, particularly regarding dynamic call resolution (which uses shared libraries or DLLs rather than z/OS load libraries) and the CANCEL statement. Useful for readers who want to practice subprogram calls in a PC environment and understand the portability aspects of COBOL modular programming.

9. Open Mainframe Project: COBOL Programming Course (Linux Foundation, GitHub)

The Open Mainframe Project's free curriculum includes a module on subprograms that walks through creating a calling program and a called subprogram, compiling them separately, and linking them together on z/OS. The hands-on exercises on IBM Z Xplore provide experience with the actual compile, link-edit, and execution JCL required to run multi-program COBOL applications on the mainframe.

Standards and Specifications

10. ISO/IEC 1989:2014 -- Programming Language COBOL (International Standards Organization)

The COBOL 2014 standard defines the normative behavior of the CALL statement, parameter passing, nested programs, and the INITIAL and COMMON clauses. The standard's treatment of the "run unit" concept -- the complete set of programs that execute together from the initial CALL through the final GOBACK or STOP RUN -- is essential for understanding program lifetime and storage management. The standard also defines the rules for recursive calls (introduced in COBOL 2002) via the RECURSIVE clause on PROGRAM-ID.

11. ANSI X3.23-1985 (COBOL-85 Standard)

The COBOL-85 standard introduced nested programs and the COMMON clause, expanding COBOL's modular programming capabilities beyond separately compiled subprograms. It also formalized BY CONTENT as a parameter-passing mechanism (BY REFERENCE was the only option in COBOL-74). Understanding the 1985 standard is important because the vast majority of production subprogram interfaces were designed to its specifications.

How to Use These Resources

If you want practical examples of calling and called programs, start with resources 1 (Murach's) and 3 (Coughlan) for clear, complete program pairs that demonstrate parameter passing and return value handling.

If you need to understand the z/OS runtime behavior of CALL, focus on resources 5 (IBM Programming Guide) and 6 (Language Environment Programming Guide) for the platform-specific details of program loading, storage management, and inter-language calling.

If you are designing a modular COBOL application architecture, resource 2 (Brown) provides the most thorough treatment of design considerations, including nested programs, data sharing strategies, and when to use static versus dynamic calls.

If you are debugging a subprogram-related abend, resource 6 (Language Environment) explains runtime behavior, resource 7 (IBM Language Reference) clarifies syntax rules, and resource 8 (GnuCOBOL guide) helps determine whether the issue is platform-specific or a language-level error.

Note: IBM documentation is regularly updated. Search the IBM Documentation portal for the latest edition of each title. The compile, link-edit, and execution JCL for subprograms varies by installation; consult your site's standards manual for local procedures.