2 comments about Professional ASP.NET 2.0 Design: CSS, Themes, and Master Pages (Programmer to Programmer).

1. Let me get the bad out of the way first, so I can tell you why I think you should still consider buying this book.
   
   1. Spends a bit of time on superfluous issues. For some of you, this might be a godsend, however, as development is often more than just coding these days.
   
   2. Some fairly long code samples that fluff up the book without adding a huge amount. One illustration of CSS versus tables would be sufficient.
   
   3. Not a lot of highlighting in code to point you to the points that have changed.
   
   4. Some of the explanations are thin for those without a lot of experience in this particular topic.
   
   Now that I got that out of the way, let's look at why this book should be a welcome addition to your shelf.
   
   Reason 1 is it is the only book that focuses on this particular topic. Reason 2 is this topic is extremely important, although more often overlooked.
   
   If you have an ugly, unusable personal site, it is not a big deal, as your mom will still visit. But, with business, it can be devastating. And, now, with accessibility lawsuits, it can be costly, as well.
   
   Let's start from the beginning (a very good place to start, I hear).
   
   The first few chapters are a bit of overview and express the importance of things like CSS, accessibility and good web design. None of these will make you an expert, but they will likely push those of you still in table design over to the dark side (CSS). The arguments for accessibility, including information about recent legal actions against websites, may be the kicker. Chapter 3 also focuses on using PhotoShop for designing a nice looking site. Some of the techniques will not apply to other image manipulation tools, but the basic ideas are useful for all.
   
   Chapters 4 and 5 focus on CSS. In particular, chapter 4 talks about setting up a site that appears "tabled" in CSS and chapter 5 gives you a great overview, and some practical advise, about the CSS Friendly ASP.NET controls.
   
   Chapter 6 talks about navigation and gives great practial advise on the web.sitemap file. This chapter was a godsend to me, as it finally gave me an epiphany on why roles were not working. This was actually a portion that fit #4 on my bad list, but sometimes seeing an example is enough to clue you in. :-)
   
   Chapter 7 is focused on master pages. One of the biggest aids here will be the bits on design. The pages on passing information from master to child is also very useful.
   
   Chapters 8 and 9 focus on themes. If you have a site that can be "skinned" different ways (by user or "site"), these chapters may well be worth the price of admission.
   
   Finally, chapter 10. This is one of the best chapters in the book, as it brings all of what you have learned together. It shows how to use a single code base to work with a wide variety of browser targets, including mobile devices. And, unlike many books, it does it in a very practical, real world way.
   
   There are also bonus appendices on Orcas (Visual Studio 2008) and Silverlight.
   
   Summary: Overall, this is an average book. As the only book on the topic, however, it gets a slightly higher nod. As this is a topic I have tried to drill into people's heads (i.e., building a site is as much about user experience as making things work), I would like to see as many people pick up this book as possible. Someone might come out with a better one at some time, but learning this material is a wise thing.



2. I am a hardcore .net developer. But, site design has been kind of my downside. Came across this book and had a glance at the book contents. It looked impressive and bought it. Actually, after reading it, I am glad I bought it. It covers everything that you need to consider when building a website. Not just "How" to do it, but also the "Why" of doing it. It also covers the nitty questions which you have been thinking about how they do it in the site. Explains in a simple and direct way. Jacob Sanford has done a real good job in his first book. If you are a .Net developer and would like to sharpen your design skills, this is the book to buy. It's worth it.

5 comments about Java for Engineers and Scientists (2nd Edition).

1. While the title of this book promises to teach Java, instead it mostly teaches the reader how to use specialzed bits of code that the author wrote himself. The reason I bought the book was to learn JAVA, so I could write my own code. I suppose this book would be good for people who want to be able to write Java programs without learning Java.



2. While the title of this book promises to teach Java, instead it mostly teaches the reader how to use specialzed bits of code that the author wrote himself. The reason I bought the book was to learn JAVA, so I could write my own code. I suppose this book would be good for people who want to be able to write Java programs without learning how Java actually works.



3. This book begins by showing how to implement procedural algorithms in Java. The early examples are short and understandable by those familiar with C or fortran. The commenting style is clean and concise.
   
   I have found the object-oriented portions to also be very helpful and I plan to spend more time with these sections. At first glance the emphasis seems to be on plotting data. A medium-sized scientific simulation example incorporating multiple related classes would be a great way to illustrate the design and programming suggestions made by the author.
   
   I was UNABLE to access the book's web site (www.prenhall.com/author_chapman/) or find any links to the plotting package.
   
   Overall, this was a great book for where I am on the learning curve. I would like to see how it all comes together for a more complex physical simulation.



4. Great book. Good content. Clear style. Excellent introduction to programming in Java. Wide variety of topics covered in a modest amount of pages.



5. I bought this book for a programming class. I'm experienced in c++ but wanted to learn Java. This was a great book for learning Java as a second language, but I feel that it is basic enough for the beginning programmer as well.

1 comments about Guide to Novell NetWare 6.0/6.5 Administration, Enhanced Edition.

1. Don't buy anything from this seller, i bouth a book A MONTH ago and i haven't recieved anthting, send and e-mail to the "seller" and got no response and if you check this "seller" profile you will see it is not the first time this happens, and i gave one star because it is the lowest rate in here, this seller deserves a 0.

5 comments about Operating Systems (3rd Edition).

1. Gary Nutt is incapable of writing. He is verbose and repetitive and spends a lot of time on pointless topics, such as notation for sets. Like so many mediocre authors, he fills the text with pseudo-mathematical notation to make it seem more sophisticated. The typesetting is deplorable, and I recommend he learn LaTeX.
   
   Nutt assumes the reader is a complete idiot. The book is an overview of the concepts of operating systems, which aren't remotely sophisticated. You will not learn anything practical about Operating Systems, and the concepts he covers are so trivial that you could learn in all in a day (once you extract them from the hundreds of pages or jargon and silly diagrams).
   
   I recommend "Operating Systems: Design and Implementation" by Andrew Tanenbaum and Al Woodhull instead of this trash.



2. Nutt spends an amazing number of pages covering simple topics, yet his writing is so convoluted, learning from this book is very difficult. He attempts to take a mathematical approach to such simple topics as first-come-first-served scheduling algorithm where the math simply confuses the matter. Overall, this book is boring and hard to understand.



3. Overall, this book covers the topic adequately with alot of examples and indepth applications. There are sections where Nutt can get alittle obtuse with his mathematical treatise on the subject matter. There are also alot of typo errors throughout the book so be sure to get the errata sheet. Keep in mind that computer science is a tough field and requires alot of discipline and mental apptitude. There are alot of people trying to enter this field who simply do not have the ability at this. Hence, some of the aforementioned criticisms of this book are not totally justified. The book does require work and that is what computer science is all about - HARD WORK!



4. As a text book, it is very good. I have read much worse. At some points, it will try to explain topics using actual code used by operative systems, and that can be confusing and hard to follow, especially Windows kernel code. And the exercises are hard if you do not have much practice with system software. On the good part, it is easy to read (talkative like, not lectury), and uses simple and easy to understand analogies. Another good thing about this book is that has a very complete index, and a very useful glossary.



5. This books picks up examples from real operating systems.. the conslusions at the end of every chapter make sense to anybody who has actually written code for an OS rather than one of those books that pontificate about how it is supposed to be.

4 comments about VBScript, WMI, and ADSI Unleashed: Using VBScript, WMI, and ADSI to Automate Windows Administration.

1. What a pleasure! This is a book written for technical administrators, by a technical administrator with a knack for writing. Don Jones demonstrates a talent for explaining the intricacies of monitoring and administering a Windows enterprise using WMI & ADSI scripting (et al) in a perfectly comprehensible manner without coming across annoyingly simplistic or condescendingly academic. Computer book writers take note!



2. I found this book to be very helpful and practical with the examples given in the book. The examples have come in useful for me for basic systems administration in my Windows Server 2003 network with Active Directory. The author breaks down the example codes line by line and explains what is going on, which I found to be very helpful.
   
   one thing I did not like was that some times the author purposely put mistakes in the code without initially telling you. Then towards the end of the section, he will ask you why the code did not work and will tell you what went wrong and why. He doesn't do this all the time, but a few times. It made me second guess myself and thought that the publisher had bad typos in the code, something familiarly seen in a lot of programming books. Good learning experience, I suppose.
   
   Even if you are a beginner programmer wanting to learn VBscripting, I think you would be able to get the gist of VBscript by copying the examples in the book and tweaking them for your needs. This is my first VBscript book and it's definitely a keeper for me. Highly recommended!



3. Hey all,
   
   I was a noob in all of this scripting stuff when I bought this book. Frankly it was not a bad purchase but it did leave me kind of disappointed. The first few chapters are a waste of time because there just like a huge sales ad for the author's company that sells a VBScript IDE, added to that you never get that feeling that he's fully convinced of what he is telling you, i.e. "You should learn VBScript but it doesn't matter because we have the impending doom looming over called Windows Powershell".
   
   Last but not least is the fact related to the title of my review, basically he stresses the point that to learn VBScript you should get the online documentation for it......then what the hell did I buy this book for? If I wanted to learn structured programming I would've bought a C++ book that will do a better job.
   
   All in all, the book has it's good points..I just can't remember them right now 'cause I'm hungry and it's Christmas Day. It does give you the basic knowledge what scripts can do, although if you been a windows admin for a while then this will only confirm to you that there are other ways of doing stuff....and that you need the VBScript online documentation (which by the way was hard to find on Microsoft's website) to do them.
   
   This is the only scripting book I've so sadly I can't give you an alternative to it or compare it against any but if you really are into self-learning I think that a little organization, time and all the documentation available at MS's website might do.
   
   If you have the bucks to spare buy it, if you have time on your hands don't buy and turn over to the Net to learn.



4. I had originally studied the Microsoft Press book "Microsoft Windows Scripting Self-Paced Learning Guide", but still needed more.
   
   VBScript, WMI and ADSI Unleashed is the book that I wish I had read first. It is a good choice for a system admin who wants to start scripting administrative tasks.
   
   Having never scripted before, I had many questions. This book started from the beginning, what editor should I use for programming, and took me all the way to my first scripted program....to search AD for all Servers at or below a specified OU, remotely attach to each server, determine if it is a physical or virtual computer, run a hardware configuration utility as appropriate, reconfigure the hardware as appropriate based on the utilities output and report back to me the results. I went from nothing to decent in about two weeks.
   
   This is a good choice for this type of book.

1 comments about Program Development and Design Using C++, Third Edition.

1. I used this book for a College C++ programming class. This was the required textbook, and it served it's purpose to a certain degree. It was helpful on most things and gave examples, but on certain things (like functions) I was lost, despite re-reading the book's information on it several times. I had to go get help from other sources since this book just wasn't cutting it for me. The reading is a bit dry as well, but that's somewhat to be expected from a text book. I have found many more entertaining reads in textbooks than in this one. Trying to read this late at night after class wasn't successful most of the time.
   
   In the end, it does provide the necessary information needed to learn C++, but from my experience, there isn't a guarantee that you will actually understand this information from reading this book.

5 comments about Algorithms on Strings, Trees and Sequences: Computer Science and Computational Biology.

1. If you like definition-theorem-proof-example and exercise books, Gusfield's book is the definitive text for string algorithms. The algorithms are abstracted from their biological applications, and the book would make sense without reading a single page of the biological motivations. Gusfield aims his book at readers who are fluent in basic algorithms and data structures (at the level of Cormen, Leisersohn and Rivest's excellent text). The exercises are wonderfully illustrative, being neither trivial nor impossible.

   All of the major exact string algorithms are covered, including Knuth-Morris-Pratt, Boyer-Moore, Aho-Corasick and the focus of the book, suffix trees for the much harder probem of finding all repeated substrings of a given string in linear time. In addition to exact string matching, there are extensive discussions of inexact matching. Even the discussions of widely known topics like dynamic programming for edit distance are insightful; for instance, we find how to easily cut space requirements from quadratic to linear. There is also a short chapter on semi-numerical matching methods, which are also of use in information retrieval applications. Inexact matching is extended to the threshold all-against-all problem, which finds all substrings of a string that match up to a given edit distance threshold. The theoretical development concludes with the much more difficult problem of aligning multiple sequences with ultrametric trees, with applications to phylogenetic alignment for evolutionary trees (an approach that has also been applied to the evolution of natural languages).

   Note that there is no discussion of statistical string matching. For that, Durbin, Eddy, Krogh and Mitchison's "Biological Sequence Analysis: Probabilistic Models of Proteins and Nucleic Acides" is a good choice, or for those more interested in language than biology, Manning and Schuetze's "Statistical Natural Language Processing". There is also no information on more structured string matching models such as context-free grammars, as are commonly used to analyze RNA folding or natural language syntax. Luckily, Durbin et al. and Manning and Schuetze also provide excellent coverage of these higher-order models in their books.

   This book is not about efficient implementation. If you need to build these algorithms, you'll also need to know how to write efficient code and tune it for your needs. This is an algorithms book, pure and simple.

   As a computer scientist, I found the discussions of computational biology to be more enlightening than in other textbooks on similar topics such as Durbin et al., because Gusfield does not assume the reader has any background in cellular biology. Instead, he provides his own clear and gentle introductions illustrated with algorithms, applications, open problems and extensive references. Like most Cambridge University Press books, this one is beautifully typeset and edited.




2. If you haven't read this book, you don't know biological string matching. The book's focus is clearly on string algorithms, but the author gives good biological significance to the problems that each technique solves. I came away from this book understanding the algorithms, but also knowing why the algorithms were valuable.

   No, there isn't any real source code here. That should not be a problem - this book aims above the cut&paste programmer. The book in meant for readers who can not only understand the algorithms, but apply them to unique solutions in unique ways.

   String matching is far too broad a topic for any one book to cover. The study can include formal language theory, Gibbs sampling and other non-deterministic optimizations, and probability-based techniques like Markov models. The author chose a well bounded region of that huge territory, and covers the region expertly. The reader will soon realize, though, that algorithms from this book work well as pieces of larger computations. The book's chosen limits certainly do not limit its applicability.

   By the way, don't let the biological orientation put you off. DNA analysis is just one place where string-matching problems occur. The author motivates algorithms with problems in biology, but the techniques are applicable by anyone that analyzes strings.




3. The text sits at the intersection of computer science and computational biology. It centres around the observation made by the author and others that often in CS, one has to manipulate strings of text, which are just sequences of text. While in computational biology, a recurrent theme is how to deal with sequences of molecules. These might be in a DNA sample or in a protein.
   
   Surprisingly, from this simple observation, Gusfield manages to gather together considerable material. Over the decades, computing has accrued many algorithms for text string processing. The book's merit is in presenting those which are also applicable in bioinfomatics. The level of treatment is sophisticated, from the computing vantage. Enough so that perhaps the typical geneticist might not be able to easily follow the narrative. But a researcher with a strong background in both fields might be able to benefit.



4. A well written text book with an obvious bias to biological application, but maybe most useful for its clear explanation and rigour of string algorithms.



5. This book is absolutely excellent. Gusfield walks the reader from simple concepts in string matching through advanced in a way that I found very easy to follow. Every bioinformatics researcher should have copy of this text.

5 comments about Large-Scale C++ Software Design (Addison-Wesley Professional Computing Series).

1. I read this book back in 1998. It is the foundation for my understanding of the design of object oriented software. Prior to reading this book I programmed in C++ for more than 8 years. It was apparent to me that there were gaps in my understanding of how to design medium and large scale object oriented systems. This is a huge and dense book, but as I read through it, many times a light went on in my head (those ah ha moments).
   
   The book also gives specific details about consideration for the C++ language. C++ has changed over the years, and the examples do not use newer language features. I do not feel that this is important. The code clearly illustrates the ideas, which are not limited by the state of C++ at the time the code was written.
   
   Regardless of the object oriented language you use to develop software this book will teach invaluable concepts that I have not found explained elsewhere.



2. This book assumes you're already proficient in C++ and basic OOP design principles, and considers design at a level one higher than individual classes. You'll learn how to arrange your classes into modules and packages, and then how to organise communication within and between these higher-level constructs. Nonetheless, the book never forgets that the important thing is working C++ code, not diagrams and acronyms, so it's always practical.
   
   There are two core advantages to the designs discussed in this book: maintaining the correct level of abstraction, and reducing recompilation times. Performance issues always run the risk of becoming outdated fairly quickly, and to a certain extent, some of the timing material is no longer relevant. In particular, Sutter and Alexandrescu, in C++ Coding Standards, explicitly disavow the advocated method of external header guards. Additionally, although namespaces are mentioned, they are not used much, and the older method of using prefixes is recommended instead.
   
   The last part of the book drops down to more low level concerns, such as Schwartz counters, operators, and function arguments. This leans heavily on the likes of Effective C++, C++ Strategy And Tactics and C++ Programming Style, and to be honest, you'd be better off looking in more modern books for up to date best practices. For example, in this book assignment is implemented through the copy-and-destroy idiom, which is nowadays considered to be a mistake.
   
   But this is a big book, and you won't be buying it for the lower-level stuff, but for the large amount of higher level material that makes up the bulk. The main practices and metrics remain extremely relevant, the text is clear and well written. And there just isn't many other places where you can go and read about this sort of stuff. It's a must-read.



3. This is a superb book on software design. While clearly intended for those working on large-scale projects with a broad base of users, the principles discussed are rock solid for even the smallest project. It illustrates a higher level of C++ where objects are not just used because they can represent complex concepts nicely but because proper object-orientation is insurance against many coding evils - exactly the evils which can sabotage large-scale software projects.



4. I'll start with some negative points. Due to the age of this book, much of the example code is out ot date. In particular, no bool and namespaces. This means that the advice about not polluting the global namespace, and to use structs with static members instead ought to now be advice to use namespaces. There's little on the standard library. Coverage of templates (and their potential for code bloat and link time explosion) isn't great. Another issue is the enormous improvement in computer performance since this book was written. At the time, 100MHz single core subscalar CPUs were the order of the day. Now we have 2-3GHz multicore superscalar CPUs that are of the order of 1000 times faster. What sould have taken a week to build would now take.
   
   Some of the terminoligy used doesn't match that which I'm used to. For instance, I would tend to use composition and aggregation where Lakos uses HasA and HoldsA. I don't agree with what he calls internal linkage - basically it is everything that is not extrnal linkage. I'd add a third category, no linkage (e.g., macros, typedefs).
   
   Now some more positive comments. Part II is good stuff. There is a lot of detail on why components can become dependent, and ways of breaking those dependencies. He also explains quite well the disadvantages to such insulation (generally more code and/or slower). Unfortunately, I'm not aware of any easily available tools that generate the metrics that Lakos uses. Without such tools, you either have to perform lengthy analysis (or develop your own tool), or just guess roughly the state of your own system. The end of Part II goes off the boil a bit. Packages are just bigger components, and what is true for packages is also true for components. This leads to a bit of repetition. The section on startup issues is a bit fuzzy as to whether it is a logical design issue or a physical one.
   
   Part III is good enough, but a bit off topic I feel (again getting to logical design, whilst I think the book should have stayed more with physical design). Again, there are a few things that I don't entirely agree with. For instance, advice is given to be 'const correct' [good idea in my opinion], but to only use 'int' and to avoid unsigned types. My opinion on this is that just as you should be 'const correct', then you should also be 'sign correct'. You will have a hard time using just int in real C++ code. size_t is unsigned on all of the platforms that I know, and this is the type of sizeof, the dimension of arrays, returned by strlen and so on.



5. I have to admit, this book is nothing like I thought it would be. It has more C++ than anything else. It is not "large-scale software design with few examples in C++", no sir, it is "design of large-scale software specifically in C++" !
   
   Although not all of the ideas are restricted to C++, many of them do and the book is full of C++ code. Since I haven't done active C++ development for a while (currently digging into Python), it was rather difficult to read.
   
   In a single sentence, the book is about modularization techniques in C++. The purposes of such modularization are different, from speeding up the build process, having the program better understood or refactored, to allowing modular testing or reusing code. And the techniques are different in each case too.
   
   But it is all in C++. Friendship, inlining, const-correctness, abstract interfaces, .cpp and .h file naming, private/protected/public members and/or inheritance, pimpl idiom, initialization of static objects, signed vs. unsigned, that sort of thing. All this has rather limited usability unless you are practicing serious C++ right now.
   
   Again, many of the ideas behind do apply universally, but it is difficult to find them in the thick of C++. I have found a few interesting new ideas, but I have also skimmed over many chapters because it looked too C++-ish to read through.
   
   Worth noticing is that the book is dated (1996) and therefore does not cover such essential C++ features as namespaces and templates.
   
   Only if you are doing serious C++ development. Then it would be great.

5 comments about Object-Oriented PHP: Concepts, Techniques, and Code.

1. From the perspective of a an experienced procedural PHP programmer learning OO, having read both this book and "PHP 5 Objects, Patterns, and Practice" by Matt Zandstra, I would definately recommend the latter to this book.
   
   Just because Zandstra's book doesn't have a cartoon on the front, doesn't make it less accessible. In fact I found it both more advanced and easier to understand at the same time. I imagine Lavin writing this book one chapter at a time, writing each successive chapter based on what he forgot in the previous. Zandstra's order of explanation on the other hand I found invaluable and thoughtful. When you're trying to make sense of a system by reading about it in a linear (book) explanation, the order in which the information is introduced and its context is very important.
   
   Zandstra's book is also more thorough, and seems to approach implementation from an enterprise (read proper) perspective.
   
   Lavin spends a lot of time on an example of using OO to build a system to display images in a directory. In hindsight, it turns out the design of his code is flawed in some places. Introduction material is no place to be teaching bad habits of any kind.
   
   This book is $10 cheaper than Objects, Patterns, and Practice, but I think if you're serious about learning OO in PHP the extra $10 is worth it for a higher quality book.



2. Thanks to this book now I understand the php code written on OOP style.
   After reading this book I was able to develop a very large open source project written entirely in OOP style with php5 and it was not very difficult either.



3. Peter Lavin provides us with sound, easy to understand concepts, techniques, and examples in Object-Oriented PHP. This book woke me up to the universe of OOPhp where many other PHP5 books had put me to sleep or utterly confused. If you want to get a grasp on how to implement Object-Oriented programming in your PHP code, I can highly recommend this book. It will get you moving along.
   
   I have used php since v.3 first came out. PHP's initial poor implementation of OOP completely turned me off. I found that I just did not want to do any OOP in PHP, not if that is what OOP is in PHP. Although PHP5 introduced good OOP capabilities I was so entrenched in procedural coding, and have a fairly large library of functions for a framework that I developed for my client websites that I pretty much ignored the OOP capabilities of PHP5 except in some minor cases. And all the books I got on PHP5 just left me scratching my head as to why would I want to go through all the hassle of converting the code to OOP.
   
   With an Amazon gift certificate, I picked up this book, my curiosity peeked again regarding OOP in PHP due to taking a Java class on-line. I read it cover to cover and put it down saying, good book, OOP in PHP might be worth it. Without even thinking about it, I suddenly found myself converting my framework to OOP code and loving it. Peter Lavin flipped the ol' light bulb switch to on and I got it.
   
   Object-Oriented PHP by Peter Lavin did three things, no make that four to get me to want to switch to OOPhp.
   
   1. It explained PHP's OOP concepts simply and clearly. I didn't put the book down thinking it is still all a mystery to me. For example, it didn't throw Design Patterns at me early like most of the other books so by the time I got to his brief explanation of Patterns I was ready for them. Ironically, he only discusses the Singleton Pattern and then very briefly.
   
   2. It provided useful examples of the concepts he presents. I wanted to understand the concepts of PHP and his examples helped me do that. I do wish that he would have provided more extensive code examples (or less truncated) but his explanations of the code examples were sufficient that maybe he really didn't need more.
   
   3. This book is not long. Some may actually feel robbed by its brevity but I found the concise explanation of the concepts with good examples refreshing and understandable. It kept me moving along and not bogged down so that I could finish the book. Again, I sort of wished for more complete code examples but that may have ruined the pacing of the book - maybe a follow-up "Recipe book" from the author to round it out?
   
   4. Finally, and I suppose this will sound silly, but the author gave me permission to use procedural code. This was so unlike many OOP advocates that it really stuck out although it was only one line in this fine book. More importantly, after giving me permission to use procedural code, he showed me why I would rather use OOP techniques instead. And bam! Here I am, converting thousands of lines of procedural code over to OOP.
   
   Thanks Peter Lavin



4. I'll agree with others and say that Mike Zandstra's book covers this topic better. The author goes through one example throughout the book (using classes to manipulate a file directory) without fulling explaining how some of the topics work. For example, the author gives a code example, say in english what it's doing to the files, but doesn't explain how.
   
   On the flip side, it is a good book for explaining what OOP is and why it's such and advance for PHP. I just wouldn't use this book to learn it.



5. I am an experienced sequential PHP programmer and wanted to make the jump to Object Oriented PHP.
   
   I have already learned OO concepts and programming through various classes. This book has a lot of good information that was exactly what I needed.
   
   The reading can be a bit awkward at times, and requires reading ahead to understand back(?). In other words things are used before their explained, and sometimes their used to explain other things, so you must eventually double back.
   
   PRINTED ON RECYCLED PAPER - 2 thumbs up.
   
   All in all if you are a PHP programmer wanting to upgrade, its worth the price.

5 comments about Linux iptables Pocket Reference.

1. This book is written for linux/unix sysadmins, not programmers. The topic of iptables is intimately related to guarding a network against intruders. A sysadmin task. Plus, the compact, pocketbook size lends itself to a common scenario.
   
   You're a harried sysadmin in the machine room of your company, surrounded by racks of computers and cabling. Equipment everywhere and little room for you to prop up a regular sized text on intrusion detection. Quite possibly, the master console is some cheezy old monitor that you got stuck with. Or even worse, it is just a terminal. If the latter, it's really awkward to do a man on iptables and also run it, especially if you're in real time mode against an active intruder. In other words, what this book is ideal for.



2. 'Linux iptables Pocket Reference' is an important and sorely needed reference to iptables, the interface to the Linux packetfilter used by System Admins to create firewalls, NAT routers, transparent proxies, and other 'magical' network devices. While not a tutorial, it offers good advice for those with a grasp of basic networking concepts, and a good notion of what a firewall is and what it is used for, in a dense and concise format. Sufficiently detailed information about the protocols involved obviate the need to keep additional references at hand, and make the work relatively self-contained. This should not be the first book you read about firewalls or tcp/ip, but if you are a networking professional, a technically oriented user, or just interested in creating special purpose network devices, this book belongs in your library. Those familiar with iptables will especially appreciate the lucid description of packet flow through the tables and chains, and the supporting diagrams ... they alone are worth the price of purchase.
   
   If you have need for a book on the topic, you will not be disappointed with this one.



3. Linux iptables Pocket Reference is a great book.
   
   there is a dearth of info on Linux iptables, and this pocket reference is a great book!!



4. Concise and very handy. Guides like these aren't meant to be a complete reference on iptables. Yet, the author managed to pack quite a bit into such a small book. 82pages from page 1 to beginning of index.
   
   21 pages to theory and operation -- connection tracking, accounting, NAT, SNAT, DNAT, Transparent Proxying, load balancing, and stateless/stateful firewalls.
   
   The next 61 pages are a command reference to iptables. It is in the command reference that you shall find interesting little nuggets like:
   
   1) How to rate limit incoming traffic. Specific examples provide for allowing only 10 pings per second.
   
   2) How to setup IP pools to match source and/or destination addresses. Instead of writing a line for each IP or netblock, throw the addresses into a pool and write a line for each pool.
   
   3) How to match multiple ports on the same line.
   
   and so on.
   
   Worth every penny. Lives up to O'Reilly name. Would recommend for every Linux sysadmin.



5. Last year, I was forced to become a fly-by-night system administrator. I worked for a small, local startup as its web developer, but was thrust into a sysadmin role when my boss decided to host a website on a server in our office. I was developing the site on our Ubuntu server, but was learning how to secure the server on the fly. This reference, out of all the other books I read and sites I visited, had the most bang for the buck.
   
   It's short and sweet. It describes what you should know, and gives you a reference for dealing with iptables syntax, and that's it. No flowery text, no colored pictures. Just simple "This is how to do X."
   
   If you're a sysadmin, especially if you're just getting your feet wet, get this book. It's cheap, it tells you what you need to know, and it fits in your pocket. What's not to like?