How to Use This Book

This guide explains how the book is organized, how each chapter is structured, and how to get the most out of the material regardless of your background. Read this section before diving into the chapters -- the fifteen minutes you invest here will save you hours of confusion later.

Book Organization: Nine Parts

The book is divided into nine parts comprising forty-five chapters, progressing from a rigorous revisiting of foundations through enterprise-scale capstone projects. Each part builds on the knowledge established in the parts before it.

Part I: Foundations Revisited (Chapters 1--5) revisits COBOL fundamentals with the depth and perspective that intermediate study demands. You will re-examine the COBOL landscape, development environments, program structure, data description, and numeric precision -- not as a beginner learning syntax, but as a practitioner understanding why the language works the way it does.

Part II: Control Flow and Program Design (Chapters 6--10) develops the structured programming discipline that separates maintainable code from accidental complexity. Advanced conditionals, iteration patterns, paragraph and section design, copybooks, and defensive programming techniques.

Part III: File Processing Mastery (Chapters 11--16) covers the heart of enterprise COBOL: sequential, indexed (VSAM KSDS), and relative file processing, advanced multi-file techniques, sort and merge operations, and Report Writer.

Part IV: Data Manipulation and Strings (Chapters 17--21) builds your data transformation toolkit: string handling with STRING, UNSTRING, and INSPECT, table handling and searching, pointer and reference modification, intrinsic functions, and date and time processing.

Part V: Subprograms and Modular Design (Chapters 22--26) covers CALL linkage, parameter passing patterns, nested programs, object-oriented COBOL, and inter-language communication -- the skills for building maintainable, multi-program systems.

Part VI: Database and Transaction Processing (Chapters 27--32) addresses the heart of enterprise COBOL practice: embedded SQL with DB2, advanced DB2 programming, CICS fundamentals and advanced application design, IMS/DB, and transaction design patterns.

Part VII: Testing, Debugging, and Quality (Chapters 33--37) covers the professional practices that production systems demand: debugging strategies, unit testing, code review and static analysis, performance tuning, and migration and modernization strategies.

Part VIII: Enterprise Patterns and Architecture (Chapters 38--42) provides the big-picture perspective: batch processing patterns, real-time integration, modern stack connectivity, legacy code archaeology, and the future of COBOL.

Part IX: Capstones (Chapters 43--45) presents three comprehensive projects that integrate skills from every preceding part: building a complete banking transaction system, modernizing a legacy claims processing system, and migrating a batch process to real-time.

Chapter Structure

Every chapter follows a consistent structure designed to support multiple learning styles.

index.md -- Main Content

The primary instructional material, including learning objectives, conceptual explanations, syntax specifications, annotated code examples, platform-specific notes marked with [IBM Enterprise COBOL] and [GnuCOBOL] tags, and professional best practices.

exercises.md -- Five-Tier Exercises

Practice problems organized into five tiers based on Bloom's revised taxonomy: Recall (remember facts and syntax), Understand (explain concepts and predict behavior), Apply (write code that solves defined problems), Analyze (debug, compare, and evaluate), and Create (design and implement open-ended solutions). Complete at least the first three tiers for every chapter.

quiz.md -- Knowledge Check

Self-assessment questions in multiple-choice, true/false, fill-in-the-blank, and short-answer formats. Use the quiz to verify understanding before proceeding.

Case Studies

Two case studies per chapter, presenting realistic business scenarios drawn from the GlobalBank and MedClaim running examples. Case studies are longer and more complex than exercises and simulate professional COBOL development challenges.

key-takeaways.md -- Chapter Summary

A concise summary of the chapter's most important points, useful for quick review.

further-reading.md -- Additional Resources

Annotated references to books, articles, documentation, and online resources for deeper exploration.

code/ -- Source Code Directory

Complete, compilable source files for every code example in the chapter, plus sample data files, copybooks, and JCL examples where applicable.

Three Reading Paths

Path 1: Sequential Learner

You have completed an introductory COBOL course and want a thorough, systematic progression to intermediate proficiency.

Follow the book in order, from Chapter 1 through Chapter 45. Each chapter builds on the previous. Do not skip Part I even though it revisits foundations -- the intermediate perspective on these topics is substantively different from the introductory perspective. Spend extra time on Parts III and VI, which cover file processing and database/transaction processing -- the two areas that define enterprise COBOL competence.

Estimated time: 18--24 weeks at 10--15 hours per week.

Path 2: Experienced Programmer Adding COBOL Depth

You are proficient in one or more languages, completed an introductory COBOL course or tutorial, and want to reach enterprise proficiency efficiently.

Move quickly through Part I, focusing on Chapters 4 (Data Description Mastery) and 5 (Numeric Precision), which cover topics that have no parallel in most modern languages. Slow down for Parts III through VI -- file processing, data manipulation, modular design, and database/transaction processing are where COBOL's enterprise value lies and where your prior language experience will not transfer directly. Read Parts VII and VIII selectively based on your professional needs, and complete at least one capstone project.

Estimated time: 14--18 weeks at 10--15 hours per week.

Path 3: Career-Focused Practitioner

You are preparing for or early in a COBOL development career and want to focus on the skills employers test for.

Follow Path 1 through Part VI. Then read Chapters 33 (Debugging) and 36 (Performance Tuning) from Part VII, and Chapter 38 (Batch Processing Patterns) from Part VIII. Complete Capstone 1 (the banking transaction system) in full. This gives you the core skills that employers expect of an intermediate COBOL programmer. Return to the remaining chapters as your career progresses.

Estimated time: 16--20 weeks at 12--15 hours per week.

Conventions Used in This Book

Source Code Format

Most code examples use fixed format to match production conventions. Free-format alternatives are noted where relevant. Both formats are demonstrated in Part I.

Platform Markers

[IBM Enterprise COBOL] -- Information specific to the IBM Enterprise COBOL compiler on z/OS.

[GnuCOBOL] -- Information specific to the GnuCOBOL open-source compiler.

When no marker is present, the material applies to both platforms.

COBOL Uppercase Convention

COBOL reserved words are written in uppercase following industry convention: MOVE, PERFORM, IF, DISPLAY, COMPUTE, EXEC SQL, EXEC CICS. User-defined names use uppercase with hyphens: WS-CUSTOMER-NAME, PROCESS-TRANSACTION, EMPLOYEE-RECORD.

Code Block Formatting

Code examples include descriptive labels, complete source code, annotations for complex examples, and expected output where applicable. Partial snippets are clearly marked, and complete source files are available in each chapter's code/ directory.

Tips for Success

Type the code yourself. Do not copy and paste. Typing builds muscle memory for COBOL's distinctive syntax.

Read error messages carefully. COBOL compiler messages are often more informative than those from modern compilers. Learn to read them as diagnostic tools, not as obstacles.

Do the exercises at every tier. Understanding and ability are different things. The Apply and Create tier exercises are where real learning happens.

Use the case studies. They are the closest this book comes to simulating production work. The patterns and judgment you develop in case studies transfer directly to professional practice.

Review previous material when stuck. Intermediate topics build heavily on foundational skills. If a chapter on embedded SQL is confusing, the problem may be in your understanding of data definition (Part I) or file processing patterns (Part III), not in the SQL itself.

Join the community. The GnuCOBOL forums, COBOL-focused LinkedIn groups, and the COBOL subreddit are welcoming communities where you can ask questions and connect with professionals.

Be patient with complexity. The material in this book is harder than what you encountered in your introductory course. That is by design. Enterprise COBOL systems are complex, and developing the skills to work with them takes sustained effort. Trust the process, do the work, and the competence will follow.