Compras Nikon Bluetooth |
After the concepts (a server 'listens' for a connection; a client initiates a connection) and basics of packets and sockets, the book presents a simple tcp server and client -- the server simply echos back whatever the client sends. Next, it discusses what can go wrong with the simple version, and presents an improved echo server that behave better when the client crashes (and likewise an improved client).
The book continues to improve on the basic client/server, including address resolution, and servers that handle multiple clients using forks, threads, non-blocking I/O. This is all I needed to learn from the book, and it's all in the first half of the book.
Particularly useful is Chapter 27, Client-Server Design Alternatives. To me it alone was worth the price of the book. Here the book discusses concurrent servers with three basic architectures:
(1) non-blocking I/O, no threads or forks (advantage: full control of resource allocation; disadvantag: complexity);
(2) spawn a thread or fork for each client (simplest implementation; potential problem of too many children);
(3) servers that pre-allocate a pool of threads or forks (a happy medium; faster).
Other chapters discuss broadcasting, multicasting, out of band data, routing sockets, and raw sockets; all topics I hope to learn some day. Again, this is a great book. The 3rd edition brings it up to date for IPV6 and numerous small improvements.
For those of us who have the first two editions of this book, the third edition has the following changes in effect:
á IPv6 updates. In the second version of the book, IPv6 was merely a draft and the sections covering IPv6 has been updated to take these changes into effect.
á POSIX updates. The functions/APIs and examples have been updated to reflect the changes to the latest version of the POSIX specification (1003.1-2001)
á SCTP coverage. 3 new chapters that cover this new reliable, message-based transport protocol have been added.
á Key Management Sockets coverage. Network security and its applicability and use with IPsec.
á Updated Operating Systems and machines that are used to run the examples in the book.
á Some topics such as Transaction TCP and X/Open Transport Interface have been dropped.
Many topics and sections have been updated with the authors' comments. These comments even though simple for someone new to the profession, are extremely useful as they are like hints and tips from one developer to the next to help you out in your next programming assignment.
If this is the only edition of the book that you are reading, you are in for a treat. Topics in Network Programming are covered in detail and using concrete programming examples that all of us can relate to - all Unix, but what else is there?! All kidding aside, the topics are covered well enough that they are useful information under any Operating System. The concepts don't change; sockets are sockets under any Operating System. The function call is different, but one needs to go thru the same steps under any environment.
Being the most popular networking protocol, TCP/IP is covered in Part I of the book. One needs to have prior understanding of the TCP/IP protocol and the OSI model, however. If this is the first time you are looking at the programming aspects of networking protocols, Part I of this book will cover the basics. It starts you off with a couple of simple examples such as daytime client and a daytime server and it builds on that as the reader reads along. TCP, UDP and SCTP (Stream Control Transmission Protocol) are covered in brief in Part I, and basic concepts such as the three-way handshake of TCP and the four-way handshake of SCTP are depicted.
Part II of the book covers sockets and socket programming. Topics such as the socket Address Structure in IPv4 and IPv6 for TCP, UDP and SCTP are covered and examples (the same daytime client/server) are given to convey the point to the reader. It is important to mention here that all the topics and concepts are depicted for the three transport protocols: TCP, UDP and SCTP. Every single socket API under the Unix programming environment is covered and examples are given for each function call to show the reader how the function can be utilized. An entire chapter has been dedicated to Socket Options and how they are used/can be used for best results. Hints are given throughout the chapter to tell the user about the pitfalls and best practices of each option.
After the basics have been covered, various I/O models are depicted in detail and examples are shown to convey the pro's and con's of each I/O model. The five I/O models used thru the book and available under the Unix environment are:
á Blocking I/O
á Non-blocking I/O
á I/O Multiplexing (using select and poll)
á Signal driven I/O
á Asynchronous I/O
SCTP - Stream Control Transmission Protocol, a new IEFT standard are covered in later chapters of 9 and 10 and again in chapter 23. The two interface models of SCTP (one-to-one and one-to-many) are covered in detail, and their differences with TCP are also explained in full. The client/server example that has been used throughout the book is ported to use the new SCTP protocol. The authors then go into great detail explaining the problems that SCTP solves over TCP and where and how it would be useful to use SCTP.
Advanced topics such as IPv4 and IPv6 portability, Unix Domain Protocols, Multicasting and advanced Socket programming for UDP, TCP and SCTP cover the rest of the chapters in this book.
Various options for interoperability between IPv4 and IPv6 start off the last section of the book. A chapter on Advanced I/O functions brings the reader a new perspective of how complicated Network Programming can become. Non-blocking I/O, befits and examples are covered in chapter 16. The topics on Multicasting, and adding reliability to UDP are probably my favorite chapters in this book. The Time Server that has been used throughout the book is re-coded to become a multicast application. Some issues that arise when designing multicast applications such as multicast on a WAN are also discussed.
The third edition of the UNP book is as good as ever. The updates truly reflect solutions to today's challenges in Network Programming. Bill Fenner and Andrew Rudoff did an amazing job continuing the work a true legend in the field of Computer Science.
From a simple HTTP GET to detailed network file and connectivity operations, including TCP and UDP packets, ports, sockets and so on, there is a place in the book for each kind of network programming service. There is also a fair amount of text dealing with debugging techniques, allowing even those programmers who are experienced in their craft to find new ways to ferret out the problems in their code. The book also promotes good stylistics in programming, engendering the idea that readable and understandable code is better code than that which simply works.
There are also examples and explanations for IPv6?, for any programmer who is going to be making the leap into next generation networks. There are also instructions on how to deal with wireless networks, security models and other topics for anyone who plans on designing network applications or specialized network configurations.
It's probably not accurate to rate a book on a topic that holds little interest to the reader, but even a modest script programmer can tell when a book hits a subject just right and brings out all the details in a concise, easy-to-understand way. If you're a hard-core network programmer, this book is definitely for you. If not, you may find you learn something anyway.
Surprisingly, it includes both multithreaded I/O concepts, raw sockets, routing sockets, and even IPv6 (in amazing detail) and SCTP.
This book is worth its weight in gold to anyone from a student to a professional.
Initially I did a quick scan and immediately saw some things missing (like FTP). However, after reading the book and realizing how infrequently I had referenced the missing parts in the first book, I was much happier. With the additional IPv6 information and newer technologies, this more than made up for the deletions (from volume one).
The text is easy to read and flows logically. What really impressed me was the depth of the expertise. For me, there had been some stumbling blocks in TCP and UDP development early on (especially nuances of UDP) that took a fair amount of time to figure out. I was pleasantly surprised to see many of those difficulties laid out cleanly for anyone to figure out in a matter of minutes. That alone is worth the price of the book.
The index is extensive and helpful. The questions at the end of each chapter are limited, but enough to be useful in a college course.
The printing is high quality. The paper is high quality (thin, but strong so that the 1000 page book is not huge or heavy). The printing takes up much of the page (i.e., not two-inch borders like some books). The binding lies flat without separating the pages. Definitely a quality printing.
Yes, a new classic.
There is a number of changes in this new edition that are very important. First the ccoverage of the new SCTP protocol in chapters 9 and 10. Then the coverage of the new IP protocol, IPv6 and its interoperability with IPv4 in chapter 12 and Appendix A.
In addition, the coverage of an important feature: POSIX standards which is a single UNIX specification. Plus the extensive coverage of whatever API that exist!
All owners of the previous edition realize the value of this book and the excellent quality of the material it presents. This new edition continues in the same direction with new additional contents. For people who are new to this book, this is a great book on Unix programming, a very well known and respected classic that is a must to have.
A definite recommendation.
Chapter 12 (IPv4 and IPv6 interoperability) is extremely
valuable to slightly older developers like me that have
a fair bit of IPv4 socket programming experience but that
have not had time to plunge seriously into IPv6 socket
programming. Appendix A manages to give a fairly thorough
introduction to both IPv4 and IPv6 in less than 20 pages.
This will be very popular in universities.
The book also continues to be a living history of UNIX,
where many given API calls are not only defined and explained,
but documented as to how the API call came into being, how
many different versions of the function existed, why it got
changed and when, along with recommended do's and dont's...
All around, a must buy for developers and even
non-developers who want to understand a bit of the
the true nature of the 'plumbing' that underlies
the Internet.
A scientific truth does not triumph by convincing its opponents and
making them see the light, but rather because its opponents eventually
die and a new generation grows up that is familiar with it.
-- Max Planck
Statistics are no substitute for judgement.
-- Henry Clay
