It is humbling to consider that, in this age of graphical expert systems running on networked RISC workstations, legions of programmers are still maintaining and upgrading COBOL applications. In many cases COBOL was insufficiently expressive, flexible, or fast so the applications are written partly or completely in IBM 370 assembler, and if the legions of programmers stopped maintaining the COBOL and assembler applications, we would probably all starve to death as all of the world’s payroll systems ground to a halt.

The book is a pleasantly atavistic tome. Murphy expects that the reader already knows how to program in COBOL at a junior programmer level, and he presents 370 assembler largely by analogy to COBOL concepts. Since the 370 was designed to be a good COBOL machine, and since the author wisely stays away from the parts of the architecture not amenable to COBOL analogies, the approach works pretty well. The parts he leaves out are floating point and low-level I/O and system programming instructions, none of which are of much use to business applications, anyway. The exercises all expect that the student works in a 370 programming shop with more senior people; they suggest such tasks as looking through local code for various good and bad coding techniques and finding out how the shop implements various programming conventions. It is more a commentary on the state of the programming art than on the book that 90 percent of this book could have been written in 1975, and probably 75 percent could have been written in 1965.

Murphy starts by discussing the general structure of assembler programs and proceeds to assembler data formats. As you would expect in a book for COBOL programmers, decimal and character data get the heaviest emphasis, along with control blocks for I/O operations. Then he goes on to the skeleton of an assembler routine and register usage conventions. This brings us through chapter 9.

Next is a somewhat surprising chapter on file I/O macros, surprising because the reader has not really learned any instructions yet. It works, though, since the I/O macros are as easy to understand as most instructions are.

Three chapters suffice to cover arithmetic, branching, and data movement, and two more treat subroutines and looping. Then two chapters cover sending messages to the operator and some miscellany ranging from bit testing instructions to hex dumps to the addressing peculiarities of MVS/ESA. The last five chapters cover particular programming techniques useful to COBOL programmers, such as handling I/O errors, interfacing with the standard sort/merge packages, string processing, and VSAM I/O.

Murphy’s writing style is pleasant and engaging. An occasional wisecrack relieves some of the denser descriptions without being unduly distracting. The first half of the book is quite good and manages to introduce a useful amount of assembler without the usual problem of bogging down in detail before the student can do anything.

The higher-level discussions fare less well. Many of the programming examples are stylistically dubious. In more than one place the author suggests that the way to construct an operator message at runtime is to know that the in-line expansion of the WTO macro places the message string eight bytes beyond the beginning of the macro and to store the modified string in the macro expansion. I realize that this hack has worked for 25 years, but the reentrant E and L macro formats are not that difficult.

One of the longer examples is a sample binary search in the chapter on looping; while not incorrect, it is badly written. It keeps an interval size and at each stage divides it by two, with special cases when the size runs off the end of the table, rather than the standard technique of keeping a high and low pointer, finding the middle, and then updating one or the other pointer. Even though this is not a book on algorithms, there is no reason not to use the best algorithms in the examples. The author never discusses techniques not common in COBOL programs, such as linked lists and hash tables.

The discussions of the various MVS macros in the later chapters are particularly sketchy. They seem to be enough to get the student into trouble without being adequate to write anything that really works. Since they all refer the student to the appropriate manuals, in many cases the student might as well start directly with the manual.

The book has its share of typos and minor errors. The code listings appear to have been typeset by hand, and so suffer from misaligned columns and occasional swapped lines and punctuation errors. None of the errors are particularly awful, so long as the student keeps in mind that examples that seem not to work probably don’t.

For the target audience of COBOL application programmers who need to maintain assembler applications, this book serves well. Particularly with some advice from a teacher or a senior coworker, it should allow another generation of business assembler programmers to keep those old applications working.