No comments about Learning C# 2008.

5 comments about Murach's VB.NET Database Programming with ADO.NET.

1. I took on the project of constructing a database application to track our customers since there was nothing out there off the shelf that would do exactly what we needed done. I had not programmed in 12 years and did not know a first thing about VB.NET or object-oriented programming. The book is so well structured that I managed to build a database application from the ground-up while learning to program all over again within 6 months - it would have taken shorter but the only times I could dedicate to the project was nights and weekends. And guess what; after I beta-tested the program and ironed out the bugs, the program never even crashed once! On average 15 concurrent users are on the program and enter about 200 transacions daily. This book helped make my project a success.



2. The seller responded promptly to this transaction and book was in excellent condition! Would use again and highly recommend to others....



3. this book is more of a guide to teach someone how to program, but when you are alone and stucked, you can't find any solution.



4. I'm basically a Java programmer and I already own Murachs's JSP which is a class in itself. I had to involve in a project at my company which is totally developed using VB.NET. I came here to amazon to look for some books on Vb.NET and ADO.NET and I knew Murach should have written a title on this. My guess didn't go wrong and I just bought this book 2 days ago. I was able to master the basics of ADO.NET(first 6 chapters) in just 2 days which is really unbeleivable. This book is really amazing. This is truly geared towards a beginner and also serves as a reference for experienced.
   Murach's idea of explaining the concept on the left hand side and examples for the explanation on the right hand side is really awesome. The topics are clearly illustrated with appropriate examples.
   I'm now truly a fan of Murach's pen!



5. This book provided me all the important information and techniques on how to develope relational databases. The authors really got to the guts on how real databases work. For instance, using two or more tables in a dataset, creating relations with these tables, using data binding controls where certain combo boxes are bound to a different table in the dataset. So, one can develope a user interface where certain textboxes and combo boxes are connected to other tables all on one form. I actually created my own mini database from this book. All the code worked like a champ. Keep in mind that one should download the application files from their website for each chapter. Once you run the programs for each chapter, you will understand the concepts the authors explain about the code. Make sure you have a minimal background on your standard VB.NET because the authors are not neccesarily going to hold your hand throughout the book, but they do come close.

5 comments about Object-Oriented Neural Networks in C++.

1. Well, this text isn't in any way a decent introduction
   to the theory of Neural Networks. Beside explaining you that NN are built upon nodes and links and that nodes have values and links have weights, which you can probably figure out by yourself, it present NN rules and techiques without a word about why this is so. For example the formulas used to modify
   the NN values during the training process are gives "as is", so
   that you you must just copy them and use them without having a clue at what is going on. So why do I give it 4 stars? Because
   it does have working source code, and not in some weird language
   like Lisp but good old C++. C++ gurus might indeed have more than a grumble with the quality of the code, as it has some
   glaring faults, both in style and concept (like attempting to inline virtual functions and poor distribution and organization of code among header and source files) but hey, it is very simple to understand, and it works! And that is already something especially for someone who is a beginner both in NN and C++. The NN described are ADALINE, Back Propagation NN, Self Organizing NN and Bidirectional Associative Memory, (in case this tells you something) but with a little work and study you can reuse part of the framework to create new architectures. I definitely prefer a book with working, explained code than a tome full of abstraction and algorithms whose implementation is left as an exercise to the (clueless) reader. At least with this book you can play with the code and see NN in action. To really understand what is going on though you will need a theory book. As a gentle introduction I recommend Fundamentals of Neural Networks, by Laurene V. Fausett



2. The book was instructive about Object-Oriented Neural Networks. The code is really bad, but I assumed it was because he wrote it first using STL, then was told that some people may not be able to compile it because they wouldn't know how to set up STL or because of compatibilities ... but then some things just seem lazy, like making every function inline in the hopes that inline would be "better" somehow.

   I thought the code could be forgiven if there were some UML diagrams or if there were references to patterns. The index was unusably tiny. I wished there was some place we could get code updates or other versions of the code. However, there aren't many cheap books in this area of expertise, so it is still worth looking through ... try re-writing everything in Perl or Java to get away from the bad code.




3. I use the source code from this book for a two weeks practical course in
   neural networks for biology students. There is much to criticize about C++
   style, OO-design, and even about the implementation of some networks (In the
   backpropagation algorithm corrections to the weights should be made only after
   the backpropagated error has been computed for all units in the
   network).

   However, I think it is great to have some reasonably well documented code to
   play with. Within a day or so the students manage to run the first networks
   without being C++ experts. In my view, it is extremely instructive to have
   some source code, even if it is not the best. A nasty fact, though, is that
   the code does not compile from the scratch (I have a little perl script that
   replaces some errors in the sources, such that the code complies nicely using
   g++ under Linux: look for it on my webpages under the
   topic "teaching"; I don't give the address here, because it might change).

   Summarizing, I like the book for what it is, an example of OO implemented
   neural networks. I would not use the code for a "real" project nor expect to
   learn from the book why networks work the way they do.




4. I have to agreed with the major of reviewers, but I think many have missed the point. As a C++ programmer and Neural Network Developer, the basic concepts of design and reuse are very good. I have remaked may of these into my own NN library and continue to improve upon it. Why he decided to use his own link list instead of the standard template libraries vector or list class is a mystery to me, but was very easy to implement into my library as was many other modifications I have made and expanded. The one thing I didn't care for was his examples as they provided no explaination, nor reason.



5. I'm preparing for my PhD in Computer Science. My work involves artificial neural networks (ANN) with Java implementation. This book is a very good start for an object-oriented implementation of ANN. Four ANN models are addressed in the book (BPN, SOM, BAM and ADALINE). However, you need to have a solid background in C++ to be able to make use of the concepts presented.
   Unfortunately, it does not cover threaded implementation of ANN. Still, though a bit old, I find the book useful.

5 comments about COM and .NET Component Services (O'Reilly Windows).

1. This is one of the best technical books, I have read. It assumes knowledge of COM and object-oriented technologies. The clarity in the areas COM+ interception, threading, security, transaction handling is exceptional.



2. I have read several books now on COM+ and MTS before it, and I have never quite understood how everything ties together and works together. So I have been stumbling in the dark on this for years. My components work, but I never knew if they worked optimally.

   This book changed all that. Finally, it all makes sense. This is by far the best book on this subject that I have read. Every piece of COM+ is explained clearly and with enough detail to get the point across without bogging down the reader. It even answered some difficult mysteries for me such as "Why is the JITA checkbox greyed out for my transactional components?" I couldn't even find an answer for that one on the newsgroups.

   The .NET coverage is brief and was probably an afterthought (in that it appears in a chapter at the end rather than integrated throughout the book), but it is enough to get started. I am looking forward to a second edition of this book that focuses on .NET and has all the code examples in C#. Juval, please write that!




3. The book was in excellent condition and looks like new. Although the shipping was 2 days late but based on the book condition its worth waiting.
   I can rate A++.



4. Don't get me wrong!! It's a great book, for understanding COM+ and use it, without all the headache of learning "why".
   But i think many people would believe is a good about .NET and how to use COM Services, but you will get only a few pages about implementing both technologies together.
   But, like i've said, it's a good book about COM Services.



5. Don't worry about the slight .Net presence in the book; there is no "new generation" of COM+ in .Net, .Net simply includes COM+ (of course there is a new name for it: Enterprise Services, but this is just pure marketing matter)!
   I haven't finished the book yet, but I can say Juval found the right way in explaining most of the COM+ features and why are they indispensable in building enterprise apps by focusing on the business logic and not on the plumbing (object pooling for supporting scalability, transaction management, synchronization etc). The writing style is clear, the content is exhaustive enough for covering all the aspects of COM+/.Net Enterprise Services and, the last but not the least, the book has less than 400 pages.
   Other recommended books about COM+:
   -Transactional COM+, by Tim Ewald: if you need to know more COM+ internals about contexts, apartments etc.
   -Programming Distributed Apps with COM+ and VB6, by Ted Pattison: excellent lecture, easy and explains very well the "why"s.
   - Visual Basic and COM+ Programming: by Peishu Li. Very similar style with Juval's book, except that the code is VB instead of C++.

5 comments about UML for Mere Mortals(R) (For Mere Mortals).

1. This book was written for managers in need of knowledge concerning the return on investment (ROI) of using the UML in their software development projects. It is not a compact, diagram-laden book of detailed descriptions of how the UML is used to represent the actions of software. Most of the explanations are in text; drawings are used more as an emphasis tool rather than as an initial descriptor. The explanations are very readable, much more common-sensical than technical.
   How the UML is used throughout the entire product lifecycle is covered, from describing business models to modeling the testing process before release. At the end of each chapter, there is a list of key terms, a summary and a short list of review questions. Most are T/F or multiple choice and the solutions are included in an appendix.
   As long as you use it for the purpose for which it was designed, this is a very good book. You can't use it to learn how to use the UML to precisely model your projects, but you can use it to quickly understand the value you can obtain from using it. I strongly recommend it for all stakeholders in a project where they do not have to actually build the software. I included it as one of the best books of the year 2004 in my yearly column in the online Journal of Object Technology.



2. The sheer number of books on UML is simply amazing, and it seems like finding a right one for you is a task all into itself. No matter whom you want to become, a hardcore UML modeler or a weekend reader feeding one's curiosity, the book "UML for Mere Mortals" is a great way to start. The main and important topics are covered, and the details are left untold. That's perfectly ok, since even the UML professionals don't refer to all aspects of UML due to its complexity. Simple UML diagrams are easy to grasp, but UML for large projects get very complicated, making the users of UML stick to common diagrams in order to get the point across more easily to readers. What is the point of a complex and intertwined diagram if you are the only one that can read it?
   
   It is crucial to keep in mind that the goal is to model your enterprise in order to have a common language across all aspects of business via which everyone can communicate. What is the point of accomplishing this task if no one else in your enterprise can understand what you are trying to say? You have accomplished nothing, and only wasted away hours of work. The authors of the book have this mentality in mind when they are talking about UML. They start with basic stuff such as Business Modeling and Business Use Cases: a top-down approach if you will. The fact of the matter is that UML can readily model all aspects of an enterprise from what is called Business Use Cases all the way down to how each executable piece of software is deployed.
   
   After Business Modeling has been accomplished, it is onto requirements modeling with Use Cases. A Use Case driven process, where your capture your requirement solely using Use Cases has shown to be the best way to start a new project. The concept of "separation of concerns" fits perfectly into this methodology, and there are a number of books that talk in detail about it. After capturing your requirements, it is now time to get working on the Architectural designs using Class Diagrams, and think a bit about deployment and component diagrams. A more difficult task is to model your application, and not only pieces of it. After wrapping up with Class Diagrams, the authors show you how to go about modeling your entire application. It is a difficult task, but the authors break it down to easy to chew off pieces for the reader.
   
   Database Modeling and Testing are probably my two favorite chapters in this book. These are topics that one would normally not think about when thinking about UML, but the authors show that it is not the case. In fact, modeling your database with UML will enable all your team members to have a common language (that phrase again!), and maybe even reuse components from each others design. The same goes with testing. Authors suggest that the QA team should take the Use Case and Architectural Models and start working on test cases while the development is taking place. This is a great idea as you catch bugs early in the process and the cost of fixing them is very small comparatively.
   
   UML for Mere Mortals is an easy and quick read. If you want a book to refresh your UML skills over the weekend, or you are new to UML and need to know the essentials fast, this is the book to read.



3. "UML for mere mortals" is a very creative book, with great examples, that makes UML easy and fun to learn!
   This is a must read book for all those who are being introduced to UML or are looking for UML 2.0 updates!
   
   Really easy to read... I enjoyed the way they link UML 1.X to UML 2.0!
   All the modeling essencials for software intensive systems are covered in this book... And it also presents a wide approach for UML modeling, from Business Modeling through Testing!



4. I don't care what the experts say... UML isn't intuitive nor is it "easy" to read. Learning to use it can be intimidating. UML For Mere Mortals by Robert A. Maksimchuk and Eric J. Naiburg is a very nice way to get your feet wet on the subject...
   
   Chapter List: Introduction to the UML; Business Models; Requirements Modeling; Architectural Modeling; Application Modeling; Database Modeling; Testing; Is That All There Is?; How Do I Get Started Using The UML?; Where Can I Learn More?; Glossary; Answers To Review Questions; UML Diagrams and Elements; Index
   
   I've read a few books on UML, and it's pretty easy to get bogged down in all the rules and minutiae. UML is one of those things that can have the experts arguing about fine distinctions that you'll never experience in your working career. In this book, you can forget all that. The authors don't try to teach you absolutely everything there is to know. The goal is to focus on practical usage and cover those things that you'll most likely run up against in real life. And in my opinion, they nail that goal. Most of the subtopics within each chapter have a topic heading that is a question. The questions are ones that you'd encounter as an actual student of UML (like how do I model my business using the UML?), and that tends to make sure the subject matter stays practical and useful. There are also a number of very good sidebars that cover lessons learned, real world experience, things to watch out for, and "deep dive" items that cover things in a bit more depth. There are even review questions you can use to see how much you've retained. All in all, a good format and packaging of the material.
   
   This is the first "Mere Mortals" title I've read, and I don't think it will be my last. I see this as being a book that you'd use to get up to speed quickly on a subject. It could also be used to learn what you don't know. If I knew nothing about UML, this book, read straight through, would give me the context for everything else I need to learn. Books like that are really valuable, and this one would be a great addition to your UML bookshelf if you need to go in that direction...



5. UML is still as much an art as a science, and as proof I'd offer the fact that UML - despite industry-wide agreement of it being a Very Good Idea - still has very few native "speakers" who can offer the formula for how to do it successfully. Witness the effort of the two authors with decades of previous success in applying UML (and, as members of the Rational team, much future success tied to the successful application of UML) as they dispense the following:
   
   Rule 1: "Use cases should not describe how the scenario will be implemented." - p.67 (this is the traditional design dogma, that it is even possible to describe a problem in a meaningful way that produces value without first acknowledging some aspect of the solution - see Kovitz's "Practical Software Requirements" for more on this)
   
   Example: The authors offer an example where an actor (Driver) will perform a scenario (Take Trip) which will always include another use case (Fuel Vehicle).
   
   Inconsistency:
   * By specifying Driver, haven't we already made some assumptions about the particular implementation - that we are describing a car as the vehicle, and that a vehicle is even necessary to take a trip? Can't the individual just walk?
   * Does every occurence require a vehicle to be fueled? What about a trip across town?
   * Could this be a bike rather than a motorized vehicle?
   
   Assessment: The point of this use case would be that the value proposition to the "driver" is to take a trip, not the act of driving a vehicle, so therefore it would make more sense to abstract the vehicle out of the equation and therefore break the inclusion of the Fuel Vehicle case.
   
   Rule 2: "[U]se cases should be defined from the viewpoint of the actor that would use them, not from the system's viewpoint" - p.68
   
   Example: A written use case for retrieving records from an archive, where the first step is that the record is locked against update.
   
   Inconsistenency:
   * How exactly is a database lock occurring from the Actor's viewpoint? How is this not acknowledging the the eventual system implementation?
   
   Other miscellaneous nonsense:
   
   Statement: "[The use case has ] post-conditions that must be true after the use case is run" - p.80
   
   Example: The use case's post-condition is stated as 'The Records Closure Schedule and Records Destruction Schedule may be updated', ie. some tables may or may not be updated during the use case. What value is there is stating that? Is there ever a case where this "condition" isn't true? (Don't bother with any of this garbage - check out Cockburn's "Writing Effective Use Cases" for the definitive guide).
   
   Later, we drink the Kool-Aid and are introduced to the miracles of Model-Driven Architecture and Application Appliances Of The Future that "can help organizations that do not have extensive technical knowledge but that need to generate applications using the latest technology". Now everyone can develop an application: just punch in the time, hit Start, and wait. I wonder who sells these wonderous tools... Rational perhaps? This is all wasted space. No mention of real issues, such as changing requirements and how to introduce traceability of original business requirements to the application's design details. At this point, I skimmed ahead and finally quit reading the book.
   
   While I am not suggesting that the authors have not been successful in applying the UML in their lives, I would argue that their instruction is logically inconsistent. In fact, my argument here is not with the examples - that's largely the way it works when it does work - but instead with the rules as defined. If the authors cannot be expected to put together a book that holds true between theory and practice, how can the reader be expected to do so? Are we to say that the authors took liberty and broke the rules in applying their theory to the examples? If so, why? At the end of that question lies a book, because that is where there is real knowledge to be gained by the audience. This is the larger difficulty that most people have in applying the UML: when to follow the rules and when to break them. Experience plays a large part in making sound judgements regarding the UML. This book will celebrate a hollow victory with the reader, a self-help pamphlet where the parameters are tightly constrained and the chance of success is 100%. Basically it is UML T-Ball, and the reader will feel victorious until later attempting to apply these techniques in non-sequential reality, where the only true map of the world looks something like those convoluted UML collaboration diagrams that everyone shuns (and these are shunned for good reason as they provide no use to anyone but the modeller).
   
   Perhaps the underlying problem is that no language is fully descriptive, and that no language ever has hard and fast rules that are true 100% of the time - but if that is the case, the authors should still be able to develop theoretical examples that consistently follow their internal logic and give some underlying reasons why they think those rules are valid, then leave it to the reader to determine when something is appropriate.

5 comments about Test-Driven Development: A Practical Guide (Coad Series).

1. Dave's book does one thing that most other books in this field do not do: it avoids the web application. Hallelujah!

   This book provides a good foundation for understanding TDD: the programming cycle, refactoring, tools, mock objects... it is possible to begin applying TDD for yourself after reading the first 1/3 or so of this book.

   Writing effectively about programming sessions is not easy. Only a few authors can do it well, and Dave does an admirable job in this. My only beef with the case study (which makes up the bulk of the book) is that, after a while, it becomes somewhat repetitive. This isn't Dave's fault: it's the nature of programming. Sometimes we just need to add another button or another text field. We don't necessarily learn anything new doing it, but if we want a finished product, we have to do it. I understand Dave's desire to present a complete (if small) project, and so applaud his willingness to risk some duplication in the name of finishing what he started.

   The experience of learning from this book is similar to learning from real project experience: not every page contains something new and exciting, but if you follow along and ask questions (of yourself), then you will have learned a great deal by the end.




2. This book is about Test-Driven Development (TDD). Its purpose is to help you write better code (by having more tests) and give you a head start with existing tools to achieve this.

   The book falls short of these goals: The explanations about writing tests are short on advice and are sometimes misleading. The presentation of the tools is long, with little useful facts.

   The book is organized into four parts: Background on TDD, refactoring and programming by intention; A look at JUnit and related tools used to write and run tests; A lengthy example of TDD; An overview of other tools in the xUnit family. The book is targeted at a Java audience but programmers using other languages should have little difficulties understanding the code.

   I have a major problem with the background section. The author repeatedly claims that TDD provides exhaustive test coverage and ensures that you can refactor your code with confidence. Any error will be caught by the tests. This is foolish. First, tests rarely reach 100% code coverage. Even the sample that the author provides in the book ends up with less than 90% coverage. This leaves many gaps where tests will fail to detect errors. Even if tests cover 100% branches in the code tests are not exhaustive. Depending on the data used, the same branch may exhibit different behavior. (Not to speak about race conditions and other sources of hard to find bugs.) I fully agree with the author that writing unit tests will improve the quality of the code and help find bugs. But claiming that this is a silver bullet is not wise. I would recommend reading books about tests (e.g., Myers' The Art of Software Testing and McConnell's Code Complete chapter on unit testing) in addition to this book. The section on refactoring is a summary of Martin Fowler's Refactoring book which I recommend.

   The second part presents JUnit. JUnit is a framework used to write and run tests. It is a good presentation. However I would have liked to get pieces of advices on what tests to write in addition to how to write them. The author briefly mentions boundary testing but does not have much to say about the tests themselves. Again a test book is invaluable for this. The author recommends using a test coverage tool as well as Jester to measure the tests coverage. This is a great idea.

   The third section is an (overly) extended example: the author walks us through writing TDD code. This could have been a great part, giving meaning to the `practical' adjective in the book title. Unfortunately it is a long rambling, showing lots of code but short on insights. The actual `meat' of this part could be summarized in less than five pages.

   The last section presents variations on the JUnit tool. Many languages (C++, C#, VB, Python, etc) are discussed. This part would have been better put on a website rather than printed in the book. Given the changes in some of these frameworks the information is obsolete.

   The books ends with several appendices dealing with extreme programming and agile modeling.

   Unit tests are a great tool to improve code quality. Whether or not you actively practice TDD, a good book on it can provide insights into improving your code. This book contains some interesting bits of wisdom. However much of it is buried by the rest of the material.




3. (Disclaimer: I worked with the author on one large project).
   Dave Astels' book is a comprehensive work covering TDD from the ground up to advanced topics. While most of the book examples use Java and JUnit, it does cover unit testing frameworks in several other languages as well. I've read two books on the topic (the other one is Kent Beck's "TDD By Example") and I liked Dave's book better. The basics of TDD can be explained in 10 minutes however when it is applied on practice it gets complicated in at least 3 areas: 1) testing UI 2) testing with database - data setup, isolation, etc. and 3) mocks. Kent's book is more about a philosophy of TDD but it only goes through a very simple "toy" example. Dave's book really helped me to understand mocks and it does cover UI testing in great length. Mocks are an advanced topic, so it does require a good knowledge of Java and OOP. The rest of the book seems to be on intermediate technical level.

   The only thing this book is missing, I think, is a discussion about data setup and database-related testing, dbUnit, etc., other than an advice to avoid it altogether (p. 83). While you can indeed use mocks to avoid it, on the large real projects some kind of integration testing (including testing with the database) will be necessary. I hope the second edition will come out at some point!

   Overall, it's a great book for both newcomers and developers with unit testing experience. BTW, it won SD West 2004 Jolt Award.




4. Whether you are a novoice or have been practicing TDD, this book is worth reading. It is really well organized, has great examples and explains how to use available TDD tools.
   Great job, David!



5. Context: I've read a fair amount about TDD (including being a technical reviewer for Kent Beck's "By Example" book), but went a long time without getting a chance to use TDD. David Astels' book gave me a chance to get a little down and dirty with the technique and some of its associated frameworks.
   
   Maybe too dirty? As others have said, the source code in Part III of the book doesn't do what the book describes; you need to go to Mr. Astels' web site and get updated source code.
   
   I found the coverage of Java frameworks (in part II) to be very helpful; it expanded my understanding of what TDD techniques can be used.

No comments about Interactive Theorem Proving and Program Development.

No comments about The Definitive Guide to Grails, Second Edition (The Definitive Guide).

5 comments about Win32 Perl Scripting: The Administrator's Handbook (Circle).

1. If I could only have a 5 Perl books, this would be one of them. The technical writing is excellent, and it is essential "fluff-less". The examples are clear and of immediate practical value, many are based on modules authored by Dave and freely available. My personal favorite is the Win32::Daemon module for implementing Perl scripts as NT/2000 services. We can only hope that Dave will write another book expanding on ADSI and WMI.



2. Looks like auther has copied and past some scripts from internet and published book. I would not try this book at all. I had no chice but to give one star but it is not worth it. if u want to learn perl for windows search on internet you will get better information.



3. Recently I was given the task of writing some Perl scripts to manipulate processes on a Windows server. I've been writing Perl scripts on Solaris and Linux for some time, but had no idea where to start on Windows.

   One of the scripts needed to find a process by name. If the process wasn't running the script needed to start a new instance and send out an e-mail to notify the support team. Using Roth's book I was up and running in a matter of hours. Prior to that I had spent days combing the Internet looking for tips on digging into the bowels of Windows (not a pleasant image) with Perl.

   Roth gives you multiple ways to tackle a problem, but voices his opinion on why you might want to choose one method over another. However, at times he makes assumptions about your knowledge of Windows which can lead to frustration. His section on WMI (Windows Management Instrumentation) is very brief for such a complex subject for example.

   I wouldn't recommend this book for someone new to Perl, but if you are familiar with Perl and need to write scripts for Windows you will find Roth's book useful indeed.




4. This book is just awesome in that it covers different Windows libraries from Perl. The material is rather advanced in both usage of Windows libraries and Perl language usage. The topics are organized in common administrative areas.
   
   I felt the ADSI and WMI coverage was just really brief; perhaps I just want more of this good stuff. I definitely hope this chapter can be expanded in a future edition.
   
   One thing that was amazing is that Roth demonstrates how to investigate the LDAP schema of Active Directory, which is rather useful when you need to search for properties, and need to know what those properties actually are. Nothing from Microsoft that I found, documents how to do this for VBScript; I did find some rather scary C++ code that alludes this functionality, but Roth not only demonstrates it, but shows how it can be used.
   
   Anyone serious about scripting and Windows administration should snatch this book like yesterday. It will undoubtedly be an essential resource for any IT department.



5. If your looking to automate tasks on windows, and don't want to learn VBScript, this book is great for someone familiar with perl programming.

5 comments about Pro Nagios 2.0 (Expert's Voice in Open Source).

1. I recently received review copies of Pro Nagios 2.0 (PN2) by James Turnbull and Nagios: System and Network Monitoring (NSANM) by Wolfgang Barth. I read PN2 first, then NSANM. Both are excellent books, but I expect potential readers want to know which is best for them. The following is a radical simplification, and I could honestly recommend readers buy either (or both) books. If you are completely new to Nagios and want a very well-organized introduction, I recommend PN2. If you are somewhat familiar with Nagios and want detailed descriptions of a wide variety of Nagios plug-ins, I recommend NSANM.
   
   PN2 is an extremely well-written book. James Turnbull's style is very easy to understand and his message is well thought-out. One of my favorite aspects of PN2 is the author's multiple recommendations. He doesn't just explain options and features; he says what he thinks works best. Turnbull's syntax examples are very helpful and thorough.
   
   I found PN2's approach to be just what I expected and needed. A basic Nagios user could read the first five chapters (Installation, Basic Object Configuration, Security and Administration, Using the Web Console, and Monitoring Hosts and Services) and have a working, capable Nagios installation. The last five chapters (Advanced Commands, Advanced Object Configuration, Distributing Monitoring, Redundancy, and Failover, Integration Nagios, and Developing Plug-ins) address more advanced topics.
   
   I was particularly glad to see security addressed as an important topic. I liked his explanation of why not to use .htaccess files with Apache (p 92-93). PN2 also introduces working solutions for redundancy and failover (topics not explicitly covered in NSANM). The author takes steps to ensure readers really understand Nagios; for example, he explains macros well, while NSANM mentions them without much thought.
   
   I did not encounter any real technical problems with PN2, hence its high rating. I saw the author mention TCP as the transport protocol for SNMP on p 181; it should be UDP.
   
   PN2 is an ideal book for anyone who wants to run Nagios. I believe new Nagios readers should read PN2, and strongly consider NSANM as a complementary reference volume.



2. Nagios is an open-source software tool that constantly monitors your system and provides feedback when it appears that there may be a problem. Nagios is a Linux based product that allows the administrator to track a wide variety of hosts, systems, services, and just about anything else they would want to know about. Completely configurable, the administrator sets thresholds and the system creates and alert any time this threshold is met. The beauty of this sort of system is that it allows the administrator to be notified of potential problems before they become major problems.
   
   Even the notification method is configurable as it will email a message, create and instant message, use SMS paging, text messaging, etc. Once you are notified if you want to check on the system you can enter the web interface and view the current network status, notifications, problem history, log files, etc.
   
   As is often the case with open-source applications, the product is fantastic but the documentation not quite up to par. That is where this particular book comes in handy. The author goes through all the details of setting up a Nagios server from the beginning decisions of just where to place the server to the set up of individual objects, notifications, groups, permissions and exactly how to check services and objects. He even goes so far as to discuss how to integrate Nagios into other products such as Snort and developing and writing and plug-ins.
   
   Written in a style that is easy to follow for the average Linux user who is comfortable with the Linux filesystem, editing configuration files, and generally working with the command line. This is not for the new user familiar only with the graphical desktop environment. But for the Linux system administrator with an intermediate level or higher skill set Pro Nagios 2.0 is an excellent resource and is highly recommended.



3. A very good introduction to Nagios. V. thorough and detailed. I would have liked more detail on monitoring SNMP devices and server monitoring especially gathering stats from HP servers with Compaq (HP) agents installed but this may be too specialised for this book. Basic Windows server monitoring is covered. Highly recommended for Nagios novices.



4. This book is great as an introductory book for Nagios. Although it doesn't cover some advanced functionalities of Nagios in depth, it tells you enough to know about them and research more.
   
   It takes you step by step to configuring your Nagios the right way, and exploring all of it's many features along the way. I bought this book to start with Nagios, and it has succeeded to completely fulfill my expectations.
   
   There are good checkpoints on the end of each chapter, which is a nice touch.
   
   What I liked the most myself, is that author has put in "best practices" to show you not only how to do things, but also how to do them the way they should be done, which is what I expect to get out of a good book.



5. Of the books that deal specifically with Nagios, this is a good one. It goes into greater depth on topics the product documentation doesn't, such as passive checks. On other topics it makes a good companion to the documentation, providing additional examples and alternate explanations.
   
   Only down sides are several typos, and that Nagios v3.0 is nearly ready for release! So I can only hope these authors are encouraged enough to do a second edition when that happens.