“The best way to learn COBOL programming is to start  doing  it” (p. xix). The remainder of this book is consistent with this advice, given in the introduction. It includes two complete interactive programs in chapter 1; offers short, but thorough, programming exercises at the end of each chapter; and contains an appendix of complete programming projects. An accompanying CD provides the code for the book’s illustrative programs, the source programs and data for the book’s exercises, and the data and copy members for the projects.

Section 1 teaches the essentials of Cobol programming. After an introduction to Cobol in the first chapter, the second teaches how to compile, debug, and test a program using Micro Focus Personal Cobol on a PC. Chapter 3 teaches the Cobol commands needed to generate a report. Chapter 4 discusses program design, including structure charts, pseudocode, and top-down testing. Chapter 5 introduces decision and looping statements, and ends with a two-level summary report program.

Section 2 is arranged so that the chapters can be read in any order. Chapter 6 covers data division definitions and the effects of data movement. Chapter 7 covers arithmetic statements and mathematical functions. Chapter 8 explains the many date functions and their uses. Chapter 9 covers character string manipulation. Chapter 10 discusses constructing and searching tables. Chapter 11 covers code reuse, including copying data division entries and using subprograms.

Section 3 thoroughly discusses the use of disk files. Chapter 12 provides “more than you want to know about how a disk drive works” (p. 378). Chapters 13, 14, and 15, respectively, cover sequential, indexed, and relative files. Chapter 16 explains sorting and merging files.

Section 4 delves into the differences between various compilers and platforms. Chapter 17 discusses interactive programs with Micro Focus Cobol. Chapter 18 explains compilation and testing on an IBM mainframe. Chapters 19 and 20 describe interactive programs and database programs on an IBM mainframe. Chapter 21 covers maintenance programming. Finally, chapter 22 describes object-oriented programming in Cobol, with the 2002 standards in mind.

The book features paired pages--text on the left and examples on the right. Although this tactic seems strained in some places, as when explaining the use of a compiler, generally it works well. The authors make good use of sample code. They try to cover all relevant cases. They improve clarity by providing test data and sample output before providing program code. Similarly, they show how to call a subprogram before showing how to write one. Their descriptions are thorough and their examples straightforward. The “Perspective” section at the end of each chapter explains how the material in that chapter fits into the big picture.

The authors take program design seriously and encourage their readers to do likewise. According to them, “study of old programs will be convincing proof of the need to develop programs by using the structured techniques that are presented in this book” (p. 704). They warn that designing while coding degrades the quality of Cobol programs and suggest developing model programs to use for the design and coding of sequential update and maintenance programs.

The authors are also very much concerned with code clarity. They recommend, for example, that each procedure name consist of a sequence number, a verb, an adjective, and an object. They provide guidelines for documentation and testing. However, they also repeatedly remind readers that the book’s recommendations are not intended to replace any workplace standards.

Occasionally the book’s advice is so simplistic as to be almost humorous: “If you draw a chart that doesn’t fit on one page, you can easily spread it over two or more pages” (p. 146). Sometimes the simplistic advice is, nevertheless, crucial: “Save a copy of the original master file so you can restore it later if you need to” (p. 482).

I was particularly pleased that the book directly addresses common student errors and misconceptions. It emphasizes that the original data remains in the sending field after the move operation, that a period within an IF statement is a common error, and that you cannot code IF statements in AT END clauses. It also clearly explains potential debugging problems when coding with tables.

The authors claim that this book is “the best choice for both beginner and professional” (p. xv). I agree that it would be an excellent book from which to learn Cobol and an excellent reference to have available when programming in it.