The authors provide an interesting mixture of material: promotional, introductory, manual, and illustrative examples. The book, like others of its ilk, is large. It takes up over two inches of shelf space, has over 1,000 pages of material, and consists of 17 chapters divided into seven sections. Its main contribution is to give the reader an idea of the power and complexity of OS/2 and how it can be used for client/server applications. After reading this book (or the relevant part), you would have a better idea of what to ask, but probably not how to answer. That is not to take away from the book; it does have a worthy place on a programmer’s bookshelf, if he or she is interested in using OS/2 for a client/server application.

Part 1, “The Big Picture,” comprising the first 13 chapters, begins with a sales pitch for changing platforms to a client/server system, and especially for choosing OS/2 as your operating system. Consider this hype (p. 31): “OS/2 2.1 provides the almost ideal client platform of the PC world” (italics the authors’). They compare OS/2 with other PC operating systems (such as NT) and find OS/2 preferable.

Despite the size of the book, the coverage of material is superficial. This shows up especially in the first part, where the authors define concepts. The language used in descriptions throughout is colloquial and often imprecise. As an example, the entire section that defines semaphores reads: “An operating system must provide simple synchronization mechanisms for keeping concurrent tasks from bumping into one another when accessing shared resources. These mechanisms, known as semaphores, are used to synchronize the actions of independent server tasks and alert them when some significant event occurs” (p. 19). To be fair, the examples that follow in a later section do a better job of explaining the role of semaphores. In fact, the strength of this book lies in its examples.

The first six chapters of Part 1 describe client/server computing in broad terms and explain how OS/2 is a good operating system for this type of computing. Chapters 7 through 11 give a good overview of OS/2 functions and construction. These chapters explain the aspects necessary for distributed computing (for example, they cover the LAN server from a programmer’s point of view).

Part 2, “Multitasking Fundamentals” (chapters 14 through 19), looks at coding in OS/2 using C. The skeletal outline of the part mirrors the remaining parts of the book. The first chapter of each section gives an overview of the section. It is generally the weakest of the chapters. For example, chapter 14, “Processes, Threads, and Semaphores,” the introductory chapter of this section, does not give clear explanations of these fundamental multitasking concepts. The explanation of the concepts is mostly in terms of the procedures that would be used in OS/2. The concepts are vaguely defined, and then C coded examples of their application within OS/2 are given. The following chapters in a section become more specific, showing the design of a specific program that illustrates the point. These are typically well done. The following chapters in this section describe the use of daemons, multitasking, named pipes, a generic file transfer program, and an FX protocol program to do file transfers using the code developed in the previous chapters. On the way, they introduce the use of Makefiles in OS/2, discuss dynamic linking, give a brief discussion of the symbolic debugger, and cover WorkFrame/2, an integrated development tool.

Part 3 discusses “Communication Protocols for Client/Server” in eight chapters. After the tutorial chapter, this section contains a chapter on NetBIOS, two chapters on TCP/IP sockets, and chapters on CPI-C and APPC, LAN server, NetWare, and remote named pipes. A chapter in which the communication protocols are timed using a common program completes this section. These chapters build on section2 by using the common higher-layer procedures developed there.

Part 4, “The Database Manager,” has five chapters, ostensibly on the database manager, DB/2, SQL, and RSQL. One would need a background in this material before reading these sections. They pack in a lot of information, much of it specific to the OS/2 procedure calls to be used in C.

Part 5, also composed of five chapters, continuing the material in the previous part, argues that transaction servers are the best solution for online transaction processing. The authors make their case by using examples and benchmarks.

Part 6 focuses on presenting information on the user’s screen. The authors present the OS/2 tools for GUI interfacing, object-oriented user interfaces, the presentation manager, and SOM, a toolkit for metaobjects, all in five chapters.

Part 7 completes the book by pulling together the various aspects of the book using a full example, which the authors call a Club Med client/server application.

It is no wonder that this book claims to be a best-seller. It has many coded examples. I would guess that about 15 percent of the text is C code. A few tools are included in this code, but it is generally illustrative material. If this book is to be used as a reference (and it could be), it would have been nice if an appendix had been included.