Customer Reviews

Advanced Unix Programming

5 star:		(9)
4 star:		(3)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

(reviewed for the Calgary Linux Users Group Guild)

There is a saying which goes, "UNIX is user-friendly; it's just picky about who its friends are." Upon reading Advanced UNIX Programming, I get the impression that Marc Rochkind may at one time have been a close friend of UNIX, but having become a little disillusioned by what UNIX has become in the 19 years since his first edition, is willing to settle for being a calm, professional acquaintance. His opening chapter provides two main reasons why this has happened: first, the UNIX kernel has grown from providing 70 or so system calls, to over 600 for an implementation that provides Single UNIX Specification and POSIX compliance; and second, there are so many flavours of UNIX out there (including Linux) that none of them implement exactly the same set of system calls. Thus the increasing complexity and diversity of UNIX implementations makes it difficult to know all that can be called UNIX intimately. Rochkind's book presents enough material to make the reader an acquaintance, leaving the building of a friendship as an exercise for the highly committed.

Rochkind makes a careful selection of just over 300 of the most important system calls and groups them into a handful of broad topics: I/O (file and terminal), processes and threads, inter-process communication (including sockets), signals, and timers. He takes great care to highlight what is available in Solaris (version 8), Linux (SuSE 8), BSD (FreeBSD 4.6), and Darwin (6.8; MacOS 10.2.8), and how to write something that has a hope of running on all of them. The system calls he describes are the ones anyone writing UNIX applications must know about. That is his target audience, and he meets that target squarely. If you are not already a C programmer and UNIX user, this book will not be useful for you.

The book contains exercises and several code samples. Some of the larger chunks of code implement a simple shell, an HTTP client, and a full-screen text-mode menu system. This is not trivial stuff; it is reflective of the title, and demonstrates in a short space how to put the kernel to use. Rochkind also includes some example code that should work, but will not, just to illustrate that things are not as simple as they could be. He then walks the reader through the necessary corrections, bringing enlightenment as he goes. Each chapter contains this mix of tutorial material, useful to those who are starting to explore the UNIX kernel and how it can serve their applications, and reference material, useful to those looking for the bit of wisdom a man page cannot provide, but years of experience can.

Rochkind also buries some treasure in the appendices. While his examples are all written in C, since this is the natural language for UNIX programming, he acknowledges that not every program that uses the UNIX kernel is going to be a C program. He describes two downloadable class libraries that map most of the UNIX kernel calls to objects and methods. These allow folk who prefer object-oriented languages to use the kernel without doing violence to their programming paradigm. Ux is a C++ wrapper, and Jtux is a Java wrapper that also works with Jython.

As one might expect, Advanced UNIX Programming contains an extensive bibliography and reference list. If you had all of the works and resources he lists on your shelf, the body of his book would be superfluous. He has distilled things well.

There are two technical things that I found missing from the book. The significant one is a discussion of how to deal with multiple processors, particularly around semaphores and other kinds of locks. This would be a valuable addition to the chapter on inter-process communications, especially now that these machines are becoming more common. The second, and by no means serious, omission is actually one that arises because of what he does include in an appendix: if he can describe a Java class library, why not make a reference to a set of Perl modules, too?

So why do I rate this book as less than outstanding? Well, one reason is a matter of taste. I am not a fan of C preprocessor macro functions, but Rochkind makes heavy use of them in his examples to simplify error trapping and reduce the volume of code that had to be printed. This forced me to read code in a different way than my colleagues and I write it. I found it awkward to pick out the particular system call being used when it was coded as a parameter to a macro. The second is that I found his treatment of signals to be confusing. Admittedly, signal handling is not simple (and the newer signal-handling calls do little to help), but the chapter on signals felt like it was rushed to completion to meet the publication deadline. I read that chapter twice, and am still scratching my head. Add a handful of typographical errors to these irritants, and I wound up with a book that was not a joy to read straight through, but a chore. I will still use the book as an occasional reference, reflecting the comfortable professional relationship, but not intimate friendship, I have with UNIX, and maybe I will learn more on a subsequent reading.

In 1987, I encountered the first edition of Rochkind's book. Grew to depend on it as an authoritative discourse on serious unix interprocess programming. Now (finally!) he has issued an updated edition. (Has it really been 19 years?)

What is different? Much. Indeed, most of the book. In the first chapter, he summarises myriad developments in the unix world and, of course, the rise of linux. He writes for all the current unix variations and linux.

Since 1985, there has been a plethora of different interprocess communications methods. So the chapters on these form a prominent part of the book. Then, naturally, in the networking chapter, who can ignore the web? So Rochkind gives a concise detour into http, with example code for a simple browser and web server.

One thing unchanged from the first edition is the well deserved use of "Advanced" in the title. The treatment is sophisticated and, frankly, not an easy read for someone new to the subject. Rochkind writes well, but you do have to concentrate. He goes at a pace that at a very minimum assumes you are already facile in C and with using unix at the user level. The source code examples are simple, once you grasp the concepts.

The problems he furnishes in each chapter can be extremely useful if you want to deepen your understanding. The questions are nontrivial and usually expand on salient points discussed in the chapters. If you are indeed new to all this, you should make a serious attempt at the problems.

I also have the first edition (and a previous book) and am an unabashed fan of Marc Rochkind's.
What this book promises and delivers is a catalog and explanation of Unix (including Linux) system calls.
The clarity with which it is done is a thing of beauty.
It is much more dense and extensive than the 1st edition.
After all, a few things have happened in the interim.:)
This is where Unix comes alive.

The reviews posted under this title refer to the first edition of this book.
This is the long awaited and updated second edition which isn't even in the stores yet!
If it is anything like the first it is a must have.

My first two books about Unix Programming were "The Unix Programming Environment" by Kernighan and this book. Both are outdated, because when they were written there was no POSIX, XPG3 or ANSI C standards around.

Kernighan's book is ideal for Unix beginner's and offers a friendly general introduction to Unix programming and also covers shell programming very well. Rochkind's book details the basic Unix system calls and libraries.

I think that this book is still valuable and can be used as a fast course about old-style Unix programming. The best book on this subject is "Advanced Programming in Unix Environment" by Richard Stevens, that is well written, updated and covers much more topics, but takes a lot of time to read.

My favorite part is when Rochkind comments the source code of a mini-shell that can help you understand the mechanism of a real Unix shell.

But notice, Unix Network Programming isn't covered here.

You should be familiar with general UNIX commands and the UNIX OS. This text will take you help you take advantages of the UNIX system. A lot of complex ideas are set forth. I highly recommend reading this book in between watching "Takin It All Off" and "Bikini Car Wash" videos, both of which are available through amazon.com VHS video department. The analytical aspects of this book are both analytical and very aspecty. Two things I look for in a computer-based book. If you are having difficulty with this text, then get a beginning text on UNIX, like "UNIX for Dummies".

A must have, must have, must have

One of the two most useful books on unix (another one is "The Unix Programming Environment").

A very rare book with useful information about unix system calls, helps you acquire indepth knowledge about interprocess communication and unix file management system. Great book for advanced unix and c programmers.

An excellent book for people who want to understand and program under UNIX operating system. The author has done a wonderful job by building a set of library routines for interprocess communication (IPC) and shown the merits, de-merits and highlighted the usefulness of available system calls.

Use it alongwith Stevens' "Advanced UNIX programming" book.