5 comments about UNIX Network Programming: Networking APIs: Sockets and XTI; Volume 1.

1. This is one of two must-have UNIX books ("UNIX Network Programming" and "Advanced Programming for the UNIX Environment"). After I had been using UNIX for a long time and was getting into more advanced UNIX programming about a decade ago, these two books were recommended. I checked around and made comparisons. Sure enough, I had to agree. I bought both of them and use them a lot, even when doing Windows programming.

   As an example, I had to reference them again this weekend. I am using Visual Basic and C++ under Windows to connect some UDP/IP communications between applications. Once again, these books were indispensable (even after looking at online help, Google, Microsoft Knowledge Base and Experts-Exchange). Any Internet professional should have both of these books on their shelf.




2. The coding examples weren't so hot in my opinion but this book
   provided exactly what I needed to jump on the UNIX network programming bandwagon and remains a reference tool.



3. Though book is preety straight forward.
   It rarely talks about tricks,code is highly redundant in the sense that everywhere error checking is being done.
   Which makes it highly boring is that if you are dealing with some kind of N/W installation or S/W trobuleshooting.
   Talks much more on code,



4. If I want a dog, I won't buy a cat.
   The good thing of a cat is, it won't bark.



5. The Best series of books to learn Network programming from. The BEST in the world. Nothing comes close. Richard Steven rocks always !

1 comments about Operating Systems Principles.

1. hard to read. difficult to understand. not recommended. waste your money if you buy it.

5 comments about Java I/O.

1. [Review of 2nd edition]
   
   Getting data into and out of files in your Java program can be painstaking when you consider all the variations... network resources as files, compressed files, text vs. binary data in the file, etc. Java has significant power in this area, but there's a lot to know and understand. Elliotte Rusty Harold has made the task of learning it all a little easier with the book Java I/O (2nd edition).
   
   Contents:
   Part 1 - Basic I/O: Introducing I/O; Output Streams; Input Streams
   Part 2 - Data Sources: File Streams; Network Streams
   Part 3 - Filter Streams: Filter Streams; Print Streams; Data Streams; Streams in Memory; Compressing Streams; JAR Archives; Cryptographic Streams; Object Serialization
   Part 4 - New I/O: Buffers; Channels; Nonblocking I/O
   Part 5 - The File System: Working with Files; File Dialogs and Choosers
   Part 6 - Text: Character Sets and Unicode; Readers and Writers; Formatted I/O with java.text
   Part 7 - Devices: The Java Communications API; USB; The J2ME Generic Connection Framework; Bluetooth
   Part 8 - Appendix: Appendix; Index
   
   The first edition of this book was written back in 1999, and that's an eternity in computer years. Not only has the java.nio classes come into play since then, but you now have devices that were either bleeding edge or concept-only in 1999, like Bluetooth gadgets. Harold has improved the basic material to bring it up to date with the current state of Java development, and added the additional information for I/O classes through Java 6. I appreciated the large amount of coding samples that he uses to illustrate his points, as it makes it easy to adapt your learning to your own particular situation. The examples are also very focused, so you don't end up trying to filter out extraneous code to find the applicable concept you need.
   
   There's another way to use this book that makes it even more valuable than just a reference manual. If you've been coding for awhile, it's possible that you've developed some ingrained approaches to file I/O that are outdated. By simply scanning the information here, you could easily find new ways to build your applications using newer methods. Or, you might find there are language features you didn't know existed, like the ability to write your files in a compressed format without having to go through a separate utility. Two or three personal revelations like that, and the book has quickly earned its place on the shelf.
   
   While you may not use this book for every Java application you build, you'll definitely want it whenever you're working with I/O logic...



2. Not a fan of O'Reilly books, but this one stands out because of excellent NIO coverage and topical examples. It beats the the "Java NIO" book from O'Reilly hands down. Overall I'd say this book is geared for those who want to implement but covers enough detail that it probably even soothes the more 'academic' out there (those who talk a good show but do not build real-world software).
   
   Some highlights:
   
   - You'll find good coverage of cryptographic I/O aimed at practical implementation.
   
   - Excellent NIO coverage (including basic network servers in sync and async patterns)
   
   - ZIP and JAR information including dynamic class loading
   
   - Serial, USB and Bluetooth chapters (caveat: I don't use these but read them out of curiousity)
   
   - Detailed coverage of readers/writers
   
   - And obviously good coverage of the basic java.io/net packages.
   
   As of Septemebr 2006 I find the book topical and current (even had some examples of future Java 6 code). To give you an idea of the detail offered here, there is a whole chapter (37 pages) of information on File access alone including pitfalls of cross-platform implementation. Not reading/writing files...just the trappings of opening and accessing files and directories using particular patterns, URLs, etc. The actual I/O is covered in similar depth in other chapters.
   
   I'd also like to say that I highly appreciate examples that are concise and independant. There is nothing more frustrating than flipping to the middle of a book (what we all do anyway) and going through an example...only to find out that the author is using opaque references to classes and methods he/she developed on their own in five earlier chapters (bouncycastle APIs in Java Cryto for example). This pretty much makes quick-reference difficult to impossible and this book thankfully avoids it in spades.
   
   I give it five starts because it'll be well used in several projects and because it is readable and accessible to both novice and advanced developers alike.



3. Howell do you know I/O? If you don't know it very well, then this book is for you. Author Elliote Rusty Harold, has done an outstanding job of writing a 2ndedition of a book that shows you the I/O tricks and techniques used by gurus and wizards of the Java world.
   
   Harold, begins with an exploration of I/O in Java. Then, the author discusses the two most common targets of I/O, the filesystem and the network. Next, he discusses filter streams, which are Java's mechanism for processing data as you read or write rather than doing it after the fact. The author also discusses a completely new I/O model based on channels and buffers instead of streams. He continues by discussing operations on files themselves as distinct from the contents of those files. Then, the author explores how text is represented in Java and how it can be manipulated through special text streams called readers and writers. Finally, he shows you how to communicate with different kinds of peripherals and small devices that don't have traditional filesystems or network connections..
   
   This most excellent book assumes you have a basic familiarity with Java. More importantly, this book is not a language tutorial, and the emphasis will always be on the I/O-specific features.



4. It covers a lot of topics but I did find it particularly helpful in any way. The idea of gathering all the information about I/O into one book to use as a single resource is nice, but this book doesn't do a good job. Not that much help in explaining things and no help at all as far as practical examples went. You will learn much more from general Java books and Google searches.



5. Thorough guide to the java.(n)io API. Less useful as a cookbook as the organization of the book follows the API rather than focusing on specific tasks (e.g. how to best copy a file). Could have done without some of the cool chapters such as the one on J2ME (better treated in other books), or the one that describes hooking up a temperature sensor via USB, or a GPS via Bluetooth (publish these projects in a blog). Could also cut the rants about how outdated command line applications are, and I don't think the Swing-based file browser application that's built up throughout the book adds much. On the other hand I'd rather have more on performance considerations and error handling strategies!

No comments about MCDST 70-272: Supporting Users and Troubleshooting Desktop Applications on a Microsoft Windows XP Operating System.

5 comments about Multithreading Applications in Win32: The Complete Guide to Threads (The Addison-Wesley Microsoft Technology Series).

1. I bought this book to get advanced concepts of win32 multithreading which I cant get by browsing through msdn. Although this book has covered all topics, I was expecting more like a "Concurrent Programming In Java, by Doug Lee" kind of book which has a lot of gotchas. I would recommend this book for beginners looking for examples of how to use the APIs. Advanced developers should look somewhere else.



2. This material is still relevent, even when using .NET. The discussion of Win32 multithreading transcends any particular development environment used with a Windows 32 bit environment.
   
   The key idea behind this book is getting correct, reproducible results with windows multithreaded applications. Multithreaded applications are very hard to get right and even harder to properly test. The author explains the many sources of problems and how to avoid them.
   
   In order to understand this book's code samples, you will have to understand the Win32 API and code written in Visual C++ for Windows NT. It is important to see examples of these concepts in code.



3. Quite useful book. But I wont recommend it. Other than file I/O and threading, it is not for advanced programmers.
   
   From the beginning to end, it only imparts about Win95 and WinNT. None of the OS after Windows 98 are covered. So, much of information covered is obsolete.
   
   I was looking to a complete multithreading book for Windows XP, COM threading models, writing perfect multithreaded GUI application.



4. It does a very good job at describing the Win32 API for multithreading but the applications of multithreading assumed is strictly I/O related (Networking,printing,writing/reading files). The set of techniques for parallel processing on the same data is completely absent such as data organization in memory to optimize its parallel access. This is probably due to the age of the book as when it has been written, single core processor system was the norm. Parallel processing will become very important with the growing popularity of the multi core systems. Despite this weakness, this book is still my best recommendation for learning multithreaded programming on Windows since, to my knowledge, there is not yet any book tackling the subject of parallel processing on a Windows/x86 platform.



5. A beginners guide to multi-threading on WIN32. Experienced developers might find it useful to quickly skim through this book to see if there is anything that they didn't already know, but for the most part anyone with significant experience should find a different book.
   
   The language used in the book is very easy to read, making life easy for newcomers to threading, but possibly woolly enough to be slightly dangerous too, in that some stuff could bits could be misinterpreted. Developing example code using incorrect practices and then slowly fixing the problems is informative, but possibly not the best way of doing things. Why not just go for the right way first and then point out the errors that could have been made? That way it is safe for people to dip into the book and use code as is, rather than having to trawl through for a correct version. Talking about using code from books - do the authors expect the reader to trust their code when they include comments like "This happens occasionally instead of end-of-file. Not sure why" ? Certainly, that means that I would code-review anything I lifted from this book very carefully. More likely, it means that I won't lift anything from this book and will use Jeffrey Richter or Richard Gerber/Andrew Binstock instead.
   
   The book does cover a large range of Windows-related multi-threading topics - from file handling, GUI handling etc through implications for DLLs. It touches on Sockets but only very briefly, which was disappointing. Also particularly disappointing were the chapters on debugging and inter-process communications. There are too many books around that say that testing/debugging multi-threaded code is difficult without coming up with good strategies for overcoming the difficulties. Unit testing, logging and the debugger are useful, but obvious. "you must start making predictions (otherwise known as guesses)" (p268) is certainly an approach, but perhaps the time has come to use an engineering approach?
   
   The material could do with updating, as Windows, C++ and development techniques have all moved on since this book was published. Experienced developers should look forward to Jeffrey Richter's new book, planned for end of 2007, which should be as up to date as it comes.
   
   Despite referring to the CD-ROM the book didn't actually come with one. Instead the source had to be downloaded from the Addison Wesley web-site. Strangely, Addison Wesley do not have an errata for this book on their web-site. Normally I'm a big Addison Wesley fan, but they have done a few silly things with this book. The very first page of the preface had me concerned, when they hyphenated _beginthread to be _begin-thread. Given that this book is aimed at beginners I would be pretty sure that someone, somewhere tried typing that into their computer complete with the hyphen.

5 comments about Operating Systems Design and Implementation (3rd Edition) (Prentice Hall Software Series).

1. This was the text for an OS course that I took for my Masters. We had to implement 11 significant OS features for Minix (e.g. floppy disk cache, VGA driver, interprocess communication server,...) -- bugs were unacceptable (i.e. fail), as OSs must work. This class was 4 times more work that an other class I took for my Masters but I learned so much. I was already a very experienced Unix programmer when I took this, so I found it facinating to finally see what was under the hood (Minix/Unix is surprisingly small an compact -- very elegant). Tanenbaum is a real authority on the subject of operating systems and has a very engaging style. Probably the best computer science text book that I have read (I read this cover to cover, not just scanning but really reading). There is room for improvement though: the format could benefit from being updated, I had to use a lot of high-lighter. Clearer separation and indexing of key theories and sections would help. The OS basics are still relevant today (and could perhaps benefit from some expansion/clarification). I believe Tanenbaum has brought out new books since that go into some more contemporary / more advance areas.



2. While this book is good explaining theory and demonstrating it in the author's operating system, MINIX, MINIX is an insanely small OS. Now there's nothing wrong with that by default, just keep in mind that any OS you were to write in industry, etc would be way more complex.
   
   Also, beware, of the 1000+ pages, at least a quarter of that is a print out, line by line, of the MINIX 3 source code. (Approximately 30,000 lines...)
   
   Bottom line: Good for basic theory and understanding, but you would need to know much more to write a friendly OS.



3. This book is written by Tanenbaum, the main guy behind Minix, which is what Linux was based on. It provides good overviews for basic OS concepts like memory management, file systems, processes, etc. The concepts in this book book are intimately tied to examples of the Minix OS, which is a good thing.
   
   To those who would rather see examples from Linux: Minix is a compact and modular OS, which is why it's a good choice for examples. The book contains the entire source code at the back for easy reference. Yes, the OS is that small. That's a good thing when you're trying to figure out how virtual memory works or what have you. You'd be lost trying to learn this stuff from Linux. Above everything else, the code is ***well-commented*** compared to Linux, a major plus. You won't find any "/* major hack */" comments, either. ;) Minix leaves out all the crap that Microsoft and Linux throw into the kernel that make it unstable in the first place. Learn about the bells and whistles later when you can do the basics.
   
   I encountered two instances where the book wasn't updated to reflect changes in the OS, which were annoying to deal with. Also, I found a spelling or punctuation error about every ten pages, which was annoying for such a pricey book. Overall, however, the book is extremely usable and understandable. It's easy to pick up concepts from this text.



4. There is a whiff of "what-might-have-been" about this book, using the benefit of hindsight. Minix is thoroughly described as a small and impressively documented operating system. It is small enough that if you took the time, you could understand every nook and cranny. From a pedagogic standpoint, it is of great help in nailing down abstract design concepts. Amazingly, the kernel spans only 4000 lines. Nothing at all, compared to linux or other operating systems.
   
   Tanenbaum criticises those, for a lack of modularity. With millions of lines of code put into one monolithic build running in kernel mode. But you might seriously wonder about this, especially where linux is concerned. In general, it is stable. Yes, with bugs that are inevitable with large code bases. But bugs that are severe enough to crash the OS are rare. Certainly rarer than Microsoft Windows. Anyhow, the book demonstrates the use of a microkernel. While linux uses a monolithic kernel.
   
   But the "what-might-have-been" arises from how linux was inspired by minix. The marketplace has overwhelmingly preferred linux to minix. Industry giants like IBM and HP have now standardised on linux. No major company has done this for minix. It suggests a major design flaw in minix. Not a flaw in terms of not working. But a flaw at a higher level. Perhaps in extensibility or licensing. Tanenbaum must surely wonder that had he taken a different route with minix, it would have become what is linux today. Linus Torvalds is now far better known than him, and there is an entire industry of startups built using linux. Minix is something obscure, even amongst many computer programmers.



5. I like the microkernel approach to implement a UNIX-like OS. It is simple and elegant although it does sacrifice a little performance. However, the book is not particularly well-written. It lacked clarity in its explanation of both theory and implementation.

1 comments about Simple Real-time Operating System: A Kernel Inside View for a Beginner.

1. This book explains working details of an example RTOS kernel along with concepts behind its design. This book's language is simple and flows like a novel. I finished this book in a week and after reading this book I am in a comfortable position to imagine how a typical RTOS kernel work. I liked this book and advise to buy if anybody want to learn internal details of a typical RTOS kernel.

5 comments about Understanding Operating Systems, Fifth Edition.

1. This text explains OS functions and features from a conceptual standpoint, with a focus on how and why things work. An overview of the components of an OS is given, then each piece is explored in detail. The general OS model consists of a User Command Interface, Process Manager, Memory Manager, Device Manager, and File Manager.

   After covering the OS from a general perspective in the first half of the book, the second half deals with the details/differences of MS-DOS, Windows 2000, Unix, OpenVMS Alpha, and OS/390.

   This is an excellent introductory book, explaining the inner workings of an OS without using complex math and code examples. The foundation provided by this book will prepare the reader for real, hard-core OS details that are found in other OS texts.




2. When I received this book in the mail, I was curious as to why it was including a large section on MS-DOS. While there is historical and pedagogical justification for covering MS-DOS, the cover text claims that MS-DOS is one of "the three most widely-used operating systems". This statement is a bit dated. While MS-DOS may have formed the basis for early versions of MS-Windows, current versions are NT based. The book's discussion of the relationship between MS-DOS, Windows, and Windows-NT is a bit muddled.
   
   Turning to the actual section on MS-DOS, we read that MS-DOS was the "successor to CP/M" which is correct. However, the authors go on to flatly claim that "CP/M ran "8-bit machines marketed by Apple Computer and Tandy Corporation". This claim is hard to understand. CP/M was an operating system which ran on Intel 8080 and Zilog Z80 processors. The Apple II computer incorporated a Mostech 1802 processor which executed a superset of the Motorola 6800 instruction set. The two instruction sets families were mutually incompatible. Further, it is well known that Steve Wozniak produced the operating system for the Apple II. Ignorance of instruction set incompatibility is not a good indicator of textbook reliability.
   
   While the book does cover Bell Unix and Linux, it does not appear to cover BSD. BSD is historically significant in both the evolution of the unix operating system and the internet. The index also lacks a reference to the GNU project which is a pivotal component of any delivered Linux system.
   
   While this text does cover some operating system theory and does distribute architectural principles and features such as RAID systems throughout the text, it does little to explain how operating systems actually work. In particular, it does not have much in the way of code samples for key components such as the multitasking kernel.
   
   This text lacks a separate section for architecture review. It begins with a chapter on memory allocation and proceeds to a chapter on process scheduling. While architectural features are distributed throughout the text, the text can not stand alone for programs which expect student to learn systems programming.
   
   Physically, the book is handsomely produced and is of a more student-friendly size than many other textbooks. It is well illustrated with illustrations for such classic concurrency problems as the Dining Philosopher's Problem. This book may be appropriate for a course taught to future IT technicians, but should not be considered as a text for a Computer Science, Software Engineering, or Computer Engineering program.
   
   This review is for the Fourth Edition ISBN 0-534-42366-3



3. This book really hits the important info about a complicated subject. When I was studying OS in college, I didn't need to create operating systems, I needed to know what they're all about. This was the required book in my OS class and I could read and understand even the complicated stuff. It's a good starting place. This is one of only 2 textbooks that I didn't sell when I graduated. It's still a good reference. I highly recommend it.



4. The book is divided into two parts. The first part deals with the basics of operating systems which includes memory manager, processor manager, file manager, device manager and network manager. This part is presented in such a way that it can be easily comprehended by even novices and the authors did an excellent job here. The second part of the book deals with specific operating systems. Details about MS-DOS, Windows 2000, UNIX, OpenVMS Alpha and OS/390 operating systems are provided in this part. While there are few locations where the explanation is not very clear, for the most part it is understandable.
   
   This book was a required text for an undergrad course in Operating Systems I was taking. I read it from cover to cover and overall I liked it very much. I would have liked to see more visuals, examples and exercises. I will not sell this book but I will keep it for future reference. Like another reviewer mentioned, some knowledge about computer peripherals is necessary to study this book, however no specific language is assumed. Highly recommended to those who are new to this topic.



5. On page 22 at the top it speaks of a new video compression Digital Video Interface (DVI), that will compress video to a ratio of 150:1 and will store an hour length of video under a gigabyte.
   
   If you are wanting to learn the low level inner workings of an OS, skip this book.

5 comments about Inside Com (Microsoft Programming Series).

1. This book begins by assuming the reader knows little more than basic C++. In the second chapter it introduces some simple C++ classes about which the reader will think to herself, "okay, this is simple". From there it builds: adding incremental changes to the original C++ code, gradually making it more useful, explaining each change as it goes. By the end of the book, the original example has grown up into a full fledged COM component, written completely from scratch. No wizards, no templates. At this point the reader will not only be able to recognize the elements of a COM component, but more importantly, she will understand *why* COM works the way it does. The mystery surrounding the ATL and Visual Studio wizards evaporates, and the developer can see them for what they really are: simple shortcuts.



2. This is an excellent COM starting book. The author progressively builds knowledge and uses a C++ style that does not require you to memorize by heart the function, macro or template presented in page X or in windows.h. This simple, no distractions approach facilitates focus.
   
   I praise the COM reading list posted by another reviewer ("A reader"), the only book I would add to that list is "Inside Distributed COM" as this book covers the network aspects of COM like no other.
   
   Finally: Do not understimate COM's longevity... It will be with us for a long time and is stable so your investment will payoff.



3. I have been using COM for a while, then finally decided to dig further into its design paradigm and some implementation details. This book assumes knowledge of C++ and a lot of understanding of polymorphism. If you don't understand polymorphism, then it will be very hard to understand this book - but if you do, you will really enjoy reading it.
   
   This is one of the best technical books I have ever read - not just on COM. It does NOT beat around the bush. This is one of those books that can be read cover to cover - concepts are built gradually and one layer upon the next. Of course, this means that you must pause to fully understand a chapter before proceeding to the next.
   
   This book is a perfect balance - it neither goes too much into the code, nor does it hover at a high level. I think Dale Rogerson has a knack for writing!
   
   On the con side - the jokes and anectodes can sometimes get to you :)



4. This is much more than a COM book. The book spends a lot of time in the first half talking about the more general concept of interfaces, which is more of a software design topic. Then he shows how to implement those interfaces using C++ abstract classes and gives a very good discussion of inheritence, polymorphism, and virtual function tables. Everything is done in pure C++ so you can see what is going on. No wizards or macros to hide the details. The diagrams were very helpful.
   
   Even if you choose to not use the COM architecture for your software the discussion of interfaces will help you write software of much higher quality. Seeing how the interfaces are implemented and the discussion of inheritence and virtual function tables gave me a much better understanding of the C++ language.
   
   The key to understanding COM is understanding interfaces and this book does a very good job explaining them. Eventually when the author gets into the Microsoft specific COM library you can see how those chapters build on the earlier chapters. You can see how a program can evolve from a set of inflexible C++ classes, to some compile-time flexible C++ classes that use interfaces, to run-time flexible components using DLLs, and finally a full blown COM component.
   
   Near the end of the book it is not as thorough with the examples but that is because the topics presented there are too large to fit in a single chapter. The first 8 chapters are worth the price of the book.



5. This book is probably the best COM introduction book for C++ programmers. It walks you through the basics such as the IUnknown and the IDispatch interfaces, the different types of COM servers and the threading models. Everything is explained in clear writing style.

5 comments about Advanced UNIX Programming (2nd Edition) (Addison-Wesley Professional Computing Series).

1. This is an exceptional introduction to Unix features that most people won't see in every-day programming. The feature that Rochkind starts with may be the most problematic: portability. There have historically been dozens of Unices (sp?), all slightly different from each other. Even today, there are a number of different implementations in use, with small but maddening incompatibilities between them. Rochkind not only addresses the more common ones, he shows the standards-based ways of dealing with their differences.
   
   After that, Rochkind goes over read/write/open/close/ioctl again, dealing with [a]synchronous subtleties that can mean a 100x difference in performance, backed by code samples and timing measurements. The rest of the book deals with multi-process applications, including communication and distributed processing issues. That includes process groups, interprocess communication (with all its system-dependent weirdness), sockets, and signals.
   
   This isn't for the beginner or for the kernel developer, but never meant to be for either. It is a good, readable introduction to protentially tricky parts of the Unix API. I recommend it strongly to anyone building their own library of Unix references.
   
   //wiredweird



2. What's more to say, the title say's it all... Buy it!



3. I bought this book in order to get an overview on what primitives I have available on a unix system for doing system programming. I found the book to be very useful for that purpose.
   
   I use it occasionally.
   
   I also found my peers lending it from me again and again.
   
   To summarize: useful.



4. The book is good for beginners. All you need to know to get started with Unix/Linux programming.



5. I am a systems administrator professionally, but I have a need to know the inner workings of UNIX that only seems to be covered in programming books. Specifically relating to certain system calls and interprocess communication methods.
   
   This author has forgotten more about UNIX than I will ever grasp. While this book is dedicated to programming applications in UNIX and understanding the operating system's function calls, I am finding it to be a very handy reference for advanced system administration as well. The book is worth the price just for the chapters on process communication, in my opinion.
   
   I really like the author's writing style. He gets down to business and covers the material without adding a lot of needless fluff or by making the chapters overly wordy.
   
   The book is designed to server as a reference and is well-indexed, which is refreshing to find these days. It's very easy to find a topic you need as not everyone will need the amount of depth covered by each chapter in full.
   
   I wish there were more UNIX books out there like this one.