Customer Reviews

Practical UNIX Programming

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

 

 

If Stevens is the Old Testament this book is the New Testament.

I was thinking lately what it is about Stevens books that has made them the best material in the industry for the past decade. I cant really nail it, if I could I would have been an author myself and make millions, but the other day it suddenly hit me: When I read Stevens books sometimes a question arises and then I pause to think about it, only to turn the page and find the answer witinf for me. It is about being comprehensive, it is about covering all aspects of the topic, thinking forward on behalf of the reader, thinking what the reader may not understand and how to make it clear.

Well Robbins and Robbins belongs to this category of books.
I am a book maniac and I have most of the Unix/Linux programming books out there. This is by far the best systems programming book available.

The other day I had to look up about asynchronous i/o in Linux and its interaction with POSIX real time signals. Opened the book, read the example, downladed the source code, in an hour I was flying and writing an asynchronous web server in Linux.

For the networking stuff I never bothered to read the relevant chapters of the book since Stevens Network programming is the book I was trained by and it is still relevant.

For my threading needs I used to use Butenhof's "Programming with POSIX threads", but this book has great examples and I learned a lot by browsing it. I mean I had a question about signal interaction with threads and the book had a section about it. Come on, it has saved my butt many many times. It is very comprehensive.

I wholeheartedly recomend it to any serious systems programer, beginner or advanced.

This is the updated second edition that includes all-new chapters on the Web and multicast and a completely revised and updated RPC chapter. Other book chapters on files, signals, semaphores, POSIX threads, and client-server communication were updated and enhanced.

The book is organized twenty-two chapters grouped into four parts. Each part contains topic chapters and project chapters. A topic chapter covers the specified material in a work-along fashion. The topic chapters have many examples and short exercises of the form "try this" or "what happens if". The topic chapters close with one or more exercise sections.

What I liked about the book is that it provides programming exercises for many fundamental concepts in process management, concurrency and communication. These programming exercises are very similar to the exercises you would be doing in a traditional computer science laboratory as part of an operating system course, for instance. Exercises are specified for systematic development, and many can be implemented in under 100 lines of code, which is nice if you want to play with it and experiment different ways of implementing a functionality.

Another important feature of the book is the compliance with the POSIX standards. Since the last edition of the book, a single UNIX specification has been adopted and it is referred to in the book to as POSIX. The authors' examples comply with the POSIX standard.

Something else I really liked is the kind-of support available. The book has its own we site where you can download all the code in the book and email the authors and so on. Check it out at: http://vip.cs.utsa.edu/usp/.

The book basically covers whatever we need know to be able program with threads, TCP/IP, and RPC. The authors explain the essentials of UNIX programming, concentrating on communication, concurrency, and multithreading techniques and why, when, and how to use them in a very tutorial-way using a lot of reusable source code examples that explain syntax along the way.

A nice feature of the book is that it shows how to design complex software to get the best from the UNIX operating system. There are many short examples featured throughout the book and a number of hands-on projects that help readers expand their skill levels. The approach is very practical and uses short code snippets to illustrate how to use system calls.

The book is easy to read and the code examples are complete so that you can compile and run them. This is a nice feature since these exercises and code examples help readers understand and learn the material explained throughout the chapters.

If you want to:

a) Learn UNIX system programming essentials with a concentration on communication, concurrency, and multithreading techniques, with extensive hands-on examples that respect the single UNIX specifications ...

b) Write "correct" code and get the best from your UNIX operating system ...

c) Expand your ideas on how to design and implement robust UNIX software ...

then, check out this book...

With Stevens "Unix network programming" , the best book on Unix programming. Each topic is presented in one chapter and in the following a project is proposed to put in practice those concepts. Not only it explains the old and the new features of Unix, but also it is full of ideas on how to design and implement good software. Though less detailed than Stevens in the description of system calls it shows brilliantly how to design complex software and get the best from the OS. Huge source of ideas. Ideal for those who like to develop software jewels, learn about multithreading programming or even for a practical OS course at the undergraduate level.

This book is designed to be used as a text book. You will find questions at the end of each chapter and summaries typical of other text book. Usually I stay away from such books when looking for a purely technical reference, but not in this case. I examined several books looking for one that gave me the best overview of some of the more system level programming aspects of UNIX.

Don't be mislead by the title. This book is not for writing device drivers or hacking the kernel. It is very practical. It teaches topics such as process handling, thread handling, file systems and sharing, memory usage, sockets, and even Internet radio.

I bought this book to help me port a WIN32 application that made use of threads, file sharing and sockets. These are very platform specific parts of C++ and required a different implementation between Windows and UNIX. This book did a great job of showing me exactly how to port those areas of my program.

I simply was not able to find a book that had such a broad range of topics in a single book. Many examples in the book.

I bought this book as a reference for my OS course. However, I used this book more than my assigned text book. The provide code are really valuable and it does help me a lot to really understand multiprocess work. there is also another book to read if you want to understand unix programming--> advanced programming in unix environment. with them you won't encounter any diffculity any more in Unix

I used this book to start to learn from scratch how to programming Unix. This book is self-contained,concise and easy to read. FYI, it is very readable and not dry. There's a number of good diagrams, for example,illustrating file descriptors allocations and the effects of system calls like dup2, etc. The authors uses short code snipplet to illustrate how to use a particular system calls, which I think is rather neat. A number of "projects" very quickly help reader to expand their skill level. Of interest is also a project on distributed "Richard" and "Linda" , the forerunner of Sun's JINI. The authors could have expanded this book another 100 pages and make it a companion to Steven's "Advanced Unix System Programming". I strongly recommend this book to beginners, intermediate Unix Programmers.

I bought the copy for my OS course as my 2nd supplymentary book. To read this book is really fun. It clearly tells you how multiprocess, multithread works with good c code. it also covers other interesting topics like socket programming. If you really want to learn unix programming. You must have this book.

This is the type of book that doesn't leave you with more questions than it answers. It doesn't just discuss the concepts and then you're on your own for coding. It gives you enough code and explanation so that you can implement mutex locks, semaphores, threads, etc. It doesn't force you to go search online for code samples. I refer to this book often, and not just when writing code for Unix.

I took a course in Operating Systems with Dr. Steven Robbins at The University of Texas at San Antonio and (naturally) we used this book for understanding the architecture and programming of the UNIX System. The book is much like its author - organized, logical, and clear. Despite being biased, I still heartily recommend this book to anyone who would like to "get to know UNIX better." It is extrememly well organized. The examples are abundant and enlightening. Although the writing can be terse at times, it is always cogent and unambiguous. IMHO, the thing that sets this book a class apart is the constant focus on concurrency and the POSIX standard.

True, this is a text book. So it has longer examples, and it likes to put "Exercise" for all of its sections. However the book also makes an excellent reference. It was well written, and has nice diagrams to explain things like IO redirection, forking, semaphores and other basic concepts of Unix development. Its dated, and does not talk about some newer IPC capabilities such as in Linux and Solaris 10, but it makes a good introductory book...