Advanced UNIX Programming (2nd Edition) (Addison-Wesley...

Features

• Cover Type: Paperback with 736 pages
• Published by: Addison-Wesley Professional
• Edition: 2nd Edition May 9, 2004
• Written in: English
• ISBN 10 Number: 0131411543
• ISBN 13 Number: 978-0131411548
• Book Dimensions: 9.1 x 7 x 1.1 inches
• Weighs: 2.2 pounds

The publisher, Prentice-Hall ECS Professional
A comprehensive examination of UNIX® system calls--the interface between user programs and the kernel. --This text refers to an out of print or unavailable edition of this title.

Back Cover Copy

The classic guide to UNIX® programming-completely updated!

UNIX application programming requires a extreme proficiency of system-level services. Making sense of the many functions-more than 1,100 functions in the current UNIX specification-is a daunting task, so for years programmers have turned to Advanced UNIX Programming for its clear, expert advice on how to use the key functions reliably.

An enormous number of changes have taken place in the UNIX environment since the landmark first edition. In Advanced UNIX Programming, Second Edition, UNIX pioneer Marc J. Rochkind brings the book fully up to date, with all-new, comprehensive coverage including:

• POSIX
• Solaris™
• Linux®
• FreeBSD
• Darwin, the Mac™ OS X kernel
• And more than 200 new system calls

Rochkind's fully updated classic explains all the UNIX system calls you're likely to need, all in a single volume!

• Interprocess communication, networking (sockets), pseudo terminals, asynchronous I/O, advanced signals, realtime, and threads
• Covers the system calls you'll actually use-no need to plow through hundreds of improperly implemented, obsolete, and otherwise unnecessary system calls!
• Thousands of lines of example code include a Web browser and server, a keystroke recorder/player, and a shell complete with pipelines, redirection, and background processes
• Emphasis on the practical-ensuring portability, avoiding pitfalls, and much more!

Since 1985, the one book to have for mastering UNIX application programming has been Rochkind's Advanced UNIX Programming. Now completely updated, the second edition remains the choice for up-to-the-minute, in-depth coverage of the essential system-level services of the UNIX family of operating systems.

Reader Reviews
This book is truly exceptional - it covered the UNIX programming environment from beginning to the end very well. Marc Rochkind has done an amazing job updating his classic book. A brief history of UNIX and a history of various UNIX standards such as POSIX, SUS and pretty much all the others plus a thirty minute crash course in the underlying structure of UNIX get the readers going. If you are anything like me that hasn't as much a thought about how process ID's are used and the creation child processes and how permission plays a role in process creation, you will enjoy this section. I learned that its one thing to "use" UNIX, and another to really understand it deep down. The standards that are out there really throws you off though as there are so many of them. How and which one to choose? It gets rather complicated. Marc spends the first section talking about all the difficulties of "choosing a standard", and then gives you a header file that you can plug into your code and off you go. I was pleased by that. I have already started using that header file in my code and I find it rather useful. Starting from the basics of files and file access, every one of the function calls are depicted in full and example is given for each one of them. This book is like a big "how-to" notebook that one can pick and choose what to read where to get valuable information from as one needs it. Another thing that the author does throughout his book, which made me very happy, was the little tables of "stats comparisons" between the various options and settings that were just discussed. No more guessing games as to what to expect or what to test. It's all right there. I know, for example, that blocked-sized I/O of 512 bytes takes less than a second to complete versus 223 seconds when a character at a time is read. You might think that this information is rather trivial, but do you know the difference in the time that it takes to access data stored in a regular file versus data stored on a raw disk device? Accessing the terminal can get rather complicated with all the options available, and I didn't know was how much more complicated this matter gets due to the relations that terminals have with sessions and process groups. Process group, session leader, process-group leader and the controlling process could make you life as a programmer very difficult if you don't know how they inter-relate. The power of UNIX comes in a box - you have to open it to see inside, but be very prepared before you open up that box. If you have done any network programming if your life, you want to know the details and options that are available to you if you are using "select" or "pselelct". What the timeout options are, and how you can use the "poll" system call to achieve the same task as "select", but more efficiently at times. Threads, Processes and their inner workings are covered extensively in this book, as one would assume. The difference in this author's explanation of these two topics is the presentation. The author in talking about these topics, and everything else from here on, builds a fairly complete command interpreter! Starts rather small, but by the end of the book, it is a full blown UNIX like CLI with pipelines, background processes, quoted arguments, handling of I/O redirection and accepting of environment variables. Processes and threads start the discussion with "fork", "exec" and other similar and related function calls. A great deal of time is spent talking bout these two rather important calls, and how they are used, options, inheritance of those options, and programming hints and examples for each one of them. Threads and synchronization of threads via mutex and conditional variables are the next topic if discussion. Threads could get a bit more complicated, so you should spend a bit more time reading this section. The author starts you of easy though. No mutex or race conditions are considered at first. It then gets rather interesting with the various race conditions that the authors has the reader think thru. Communication between threads processes have always been an interesting topic to cover. Pipes, names pipes, shared memory and sockets. Pipes are rather easy. They have their limitations, which are discussed in full, but they are rather easy. Names pipes (queues) and unidirectional pipes get the reader going, if you have not done any Interprocess Communication before. Even if you have, it's good to revisit something that is not really used these days. Messages, semaphores, sockets and shared memory are covered in a great depth by the author. What I absolutely love about this book comes in these later sections of the book. Marc, in depicting these topics and sections builds, from scratch, what could essentially be called a middleware - Simple Messaging Interface (SMI) he calls it. SMI is probably one of the best book examples I have seen. Besides the fact that it is very useful and practical all into itself, it also promotes good network programming practice. SMI is first implemented with Names Pipes or FIFOs, then using Message Queues, then Semaphores and finally via Shared Memory. Very well done Marc. If that's not enough, all of the implementations are compared with each other, and pros and cons of each one is given to aid a developer or a designer in choosing the right methodology. The Simple Socket Interface is the Socket implementation version of the SMI. Again, very well done and prescribed by the author. Besides being very good teaching tools, they are also very practical and useful; something that we are should have in our toolbox. I highly recommend this book to any developer; designer or an architect as it is very good teaching aid for all. Comment | | (Report this)