Solaris Systems Programming

Rating:
Summary: Not a substitute for Stevens' APUE
Review: Despite the claim on the back cover, the book is far away from the tradition of Richard Stevens' "Advanced Programming in the UNIX Environment". In contrast to APUE, which truly enlightens the reader with all sorts of historical, portability, and background information, Teer's book is not much more than a Solaris API description.

Many of the examples in it will not work unmodified on Linux, BSD, or other platforms. It will thus not be of much help to a novice Unix programmer unless he actually wants to write Solaris-only programs - not a common scenario in the Unix/POSIX world. But a more experienced programmer can just use the Solaris manual pages to get most of the information contained in the book.

Also the book contains one of the most stupid code examples I have ever seen: an snprintf() emulation that works by calling vsprintf() first, then checking its return value to see if the buffer size was large enough, possibly exiting with an error message:

int snprintf (char *buf, size_t n, const char *fmt, ...) { [...]
len = vsprintf (buf, fmt, ap); [...]
if (len >= n)
err_quit ("snprintf: \"%s\" caused a buffer overflow", fmt);

But when such an overflow is actually exploited on the stack by an attacker, vsprintf() may not return at all, rendering the check useless. The code thus gives a false impression of security. This might be regarded even more dangerous than code that does not perform overflow checks at all, especially in the context of a book.

I have to admit that I did not look at too many examples, but I would recommend to be cautious with the book until somebody has verified that this is the only fundamental security error in its code.

Rating:
Summary: The Definative Guide for Programmers and SAs on ANY platform
Review: The last year has been good for UNIX programmers with several new systems programming books coming out, but they largely felt like more of the same. Finally we have a really well thought out and complete guide to UNIX Systems Programming to suppliment if not replace all those Stevens' volumes out there. Even though it's written for Solaris more than 95% of the content is OS independant (the beauty of standards). Whether your a programmer or a systems admin, and reguardless of what platform on, this book will give you a new insight into the UNIX system.

The real magic of this book is its completeness. Every code example is complete, not just acouple sample lines that don't make sense to the new programmer. Each discussion is complete from the low level concepts on up in an extremely clear and concise way. For example, before discussing a variety of memory allocation functions he explains gracefully in one page the ins and outs of memory alignment including some simple to follow guidelines; you don't see this in other guides. Another example is that the discusion of filesystem layout shows not just how an inode fits into a filesystem, but how disks, filesystems, and cylinder groups fit together. On and on, topics are discused in enough depth that unlike any other programming guide, you don't have to stop reading to "google" a subject before continueing.

The book is informative, complete, consice, and thoughtfully written. This book was written for real programmers and SAs, not as a textbook for academia (although it could serve as one). At 1200+ pages it's chopped full of real content not just headers with alittle commentary. This book even has bits of humor in it.


As we move into the new era of computing, esp on Solaris, with DTrace, new truss functionality, and tracing tools its even more important that even non-coders have this guide as a reference. This is hands-down a must have book that has finally shrunk my stack of reference books from 8 to just 3. And on top of all that, $60 list for this much material is dirt cheap. If your not sure, go to a local bookstore and flip thru it for 10 minutes and you'll come back to Amazon and buy it in a heart beat.

If your an old hat, this is the best reference you can have avalible even when compared to Stevens' legendary texts. If your a new systems coder or an SA this book will teach you things that no other single book could do alone. I certainly wish I'd had this book when I started years ago.

Rating:
Summary: Very Good Book for Crusty Sysadmins
Review: This book has been very helpful to me and will enhance my understanding of Unix and more specifically, Solaris.

Before this book, I held the book, "Unix Internals: A Systems Operations Handbook" by Shaw and Shaw as the bible of figuring out the innards of Unix. Rich Teer's new book, "Solaris Systems Programming," has taken that title and will now be my favorite Unix internals book.

The book is well-written, thorough and has many examples. I wish Teer would have put in more details on threads programming, but I guess you can only go so far.

I have recommended this book to almost all of my colleagues and will recommend it to anybody with any kind of programming background as a good reference for not only learning Unix systems programming, but learning Unix and how it works from a more detailed stand-point than the "Intro" books.

Rating:
Summary: The book each system programmer shall have...
Review: This is a book I was waiting for !

Despite of the title, this isn't a "Solaris Only System Programming" book. Most ideas on it are general ideas which can be applied to most Unix like operating systems.

A book with 1200 pages of useful information on all pages ! All covered subjects are with an agreeable style and very pertinent examples.

The pleasant style makes it an excellent book not only for learning system programing, but also as a reference for experienced programmers.

What's lacking on this book is only some aspects on threads programming, some other POSIX implementations of some System V components and other aspects of networking programming. But this isn't an argument to prevent people from buying this book. This is 1200 pages book and I sincerely hope that Rich Teer will write a second volume of his book covering this issues : I'm waiting for it.

Rating:
Summary: Excellent
Review: This is an excellent book for writing in C on the Solaris UNIX platform. If you are familiar with "UNIX Network Programming" (Stevens, Fenner, and Rudoff) and "Advance Programming in the UNIX Environment" (Stevens), then you will be comfortable with this volume. All of them contain excellent documentation and good examples, as well as a nice clean format. Although catering to Solaris, much of it is applicable to other UNIX environments as well. If you use Solaris, you will want this book.

The text is clear and easy to read, making things easy to find and use, thereby making you more productive. There are 1200+ pages, but you wouldn't think so. The paper is thin, but durable (a sign of quality publishing) and fits in with other professional publications.

This book really has a ton of stuff in it. From specific 64-bit programming topics to library function documentation to secure programming. The sections on I/O are extensive and detailed -- there could be more information on network programming (the author also refers the reader to the same "UNIX Network Programming" that I mentioned, so that is a good sign). However interprocess communications is covered very well (e.g., pipes, FIFOs, message queues, semaphores, and shared memory).

The appendices have some useful information. In addition to a function summary, the section on internationalization is good and surprisingly forward-looking. The exercises make it useful as a classroom text / reference as well.

This book already can replace several books on my shelf. Just an amazing book for your reference.