5 comments about The Rational Unified Process: An Introduction (3rd Edition) (Addison-Wesley Object Technology Series).

1. Target Audience
   IT professionals who need to learn about the Rational Unified Process (RUP)

   Contents
   This book is a relatively high-level overview of the entire RUP process.

   The book is divided into the following chapters: Software Development Best Practices; The Rational Unified Process; Static Structure: Process Description; Dynamic Structure: Iterative Development; An Architecture-Centric Process; A Use-Case-Driven Process; The Project Management Discipline; The Business Modeling Discipline; The Requirements Discipline; The Analysis and Design Discipline; The Implementation Discipline; The Test Discipline; The Configuration and Change Management Discipline; The Environment Discipline; The Deployment Discipline; Typical Iteration Plans; Implementing the Rational Unified Process; Summary of Roles; Summary of Artifacts; Acronyms; Glossary; Bibliography; Index

   Review
   The Rational Unified Process, or RUP, is a software engineering methodology that attempts to map out and document all parts of a software development project. It's extremely comprehensive, but it's also adaptable to whatever level of effort is appropriate for your situation. This book, The Rational Unified Process - An Introduction, is a good start to begin your understanding of RUP.

   First off, let me say this is not an easy read. It's a good book with all the information you need to know to start using RUP, but the information is dense and highly detail oriented. Like most developers, I'm more oriented towards coding and testing. But realistically, you need to know what the system should do before you get to the coding piece. RUP helps to put all that into a formal framework so that the necessary things will get done in the proper order.

   While the entire RUP framework might feel overwhelming, the author makes sure to let you know that you can adapt the RUP to meet your situation. If you are adding a function to an existing system, you will be more focused on use cases, development, and deployment processes. The author does a good job in segmenting the information so that you can more easily focus on your needs.

   You should also not consider this the end-all volume on RUP that you will ever need. Kruchten doesn't try to detail specific techniques like use cases or UML. You will learn where they fit in to RUP, but you will need additional information on how to implement use cases or UML diagrams. Consider this the volume that allows you to place everything in a mental framework so that you can figure out what you will need to know going forward.

   Conclusion
   If you are considering or in the process of implementing RUP, this is a book you should be studying. It's not an easy read, but it will give you the overview you need to understand the process and concepts.




2. This book introduces the logic behind Rational Unified Process (RUP). RUP is a novel idea. It puts several good practices in a consolidated package. What makes RUP useful is the fact that Rational provides all the necessary software tools to support this. This book does an average job in explaining the RUP. It over stresses obvious and well accepted concepts like "iterative development"; which makes the first half (6 chapters) of this book a bit boring. For a professional with software development and management experience, I found the first sixe chapters are best read at a cursory glance. The second half of the book introduces the workflows - and it is this half that I found more interesting. I finished this book as bed time readoing over the weekend - so this book is an easy reading. However this book is not about teaching how to use Rational Products. This book only gives an overview of the basis of origination of RUP. You would need another book to become an expert in using RUP.



3. It's an introduction, all right. The trouble is, it's such a high level introduction that there's almost no useful information whatsoever. The entire time I was reading, I was waiting for the author to get to the meat, only to discover at the end that there was none. It was like ordering a double cheeseburger, and getting two buns with ketchup and a pickle, and no beef patties.
   
   I can only assume that Rational paid the author for his time in the hopes that people, after reading this book, would purchase their entire software suite just to find out what the RUP actually involves.
   
   Despite my severe disappointment (and relief that I didn't have to pay for it myself), I can't rate it any lower than two stars. It's well written, and it could quite possibly be useful to managers and other business types who have no idea how software development works. The second star is for Rational's sheer chutzpah in getting a respected publisher to put out a $30 marketing pamphlet for them.



4. "The Rational Unified Process, An Introduction" offers readers a concise and strong introduction to the topic of the Rational Unified Process (RUP). Stressing the role of RUP in unifying the entire software development process, this book underscores the importance of efficient and effective software development.
   
   The book is structured in a logical and easy-to-follow manner and makes good use of descriptive graphics. For those with an interest in optimizing their software development processes, this is a good addition to your library.



5. After starting a few books in this series, this is the one I ended up finishing because of its readability. As an introduction to RUP, this book did its job. My only reservation is that it might be a bit too formal for those unfamiliar with the RUP jargon.

5 comments about C++ Network Programming, Volume I: Mastering Complexity with ACE and Patterns (C++ In-Depth Series).

1. This is an excellent reading for any network programmer. More than ACE itself the concepts covered are of a great value. I am a beginner to intermediate network programmer, but an experienced programmer otherwise, and found this to be an extremely valuable resource in terms tackling large application frameworks from the ground up. The concepts are precise upto the point but extremely easy to read and digest. Of course, the book is assuming that you know quite a bit of every thing else that is not covered here. There are quite a bit of things that are totally missing or not correct based on the OS and the advances in Posix threading. Nevertheless this is an excellent source for any network programmer.



2. The 2nd volume is a complement to the first.The 1st one talks for portable source code and wrapper classes. The second one concentrates on deisgn patterns & all issues in C++ network programming architecture .
   Again i say dont reinvent the wheel , give ACE a look.



3. The blurb for this book calls it authoritative. And it is authoritative in the sense that it is written by the people behind ACE. But it is not authoritative in the sense that it isn't a complete reference.
   
   As somebody who has written native code for handling Sockets, process management, threading etc on various platforms, then over time integrated OO and patterns to make it easier to use (including across platforms), and slowly worked my way towards what I consider a definitive way of doing things, I find reading this book interesting in that it's like a tick list to which I can go "yeap, I found that too" with just the odd "ooh, actually I would do that differently in this specific situation, but for the general case yes that's how I do it too". So, for me this book is interesting now, but if I was new to ACE (I'm not) or new to the underlying platform APIs I am not so sure how interesting I would find it. It gives more of a taster of what ACE can do than providing a complete tutorial. It gives more of a justification of why ACE does things the way it does rather than provide a complete reference. So, interesting for me now, but I'm really not sure who the book is aimed at. It could be used as one step of a tutorial, giving familiarity of what ACE can do, if not enough detail to really do serious stuff. It could be used to persuade people that it's usually better to use ACE than invest time and money re-inventing the wheel... Otherwise, I just don't know...
   
   Is ACE worth using? Most of the time, yes. If you need a book about ACE then this is probably the place to start, but online is the place to find the detailed information that you will need when using it.



4. My husband needed this to further his knowledge at work. Was worth the price and easy to understand for him, anyway



5. This book provided a decent introduction to ACE. However, language is little terse and presentation is not as good as ACE Programmer's book. I most liked the boxed explanations in the book, this style should have been all over the book.

No comments about Beginning XML with C# 2008: From Novice to Professional (Expert's Voice in .Net).

5 comments about Effective Methods for Software Testing.

1. There are a few things to say in favour of this book:
   1. It does walk through on how to approach testing in your organization (however, it is definitely oriented towards organizations with established testing principles).
   2. It does give you some background information on software testing. Sadly, these are mainly explained in a textbook like manner, making them hard to digest.
   3. It provides a thorough, detailed and tested methodology for software testing throughout the various life cycles. Yet again, due to the book's textbook like manners, I found it hard to actually implement the offered methodologies.

   Whatever positive attributes the book has to offer, they pale in comparison to the book's negative aspects:
   1. Total unreadability: The book written in such a boring manner, you will find yourself reading every page thrice, and still lack the satisfaction of being able to quote the meaning of what you just read.
   2. Lack structure: Paragraphs are thrown in one after the other; it's hard to decipher what leads where.
   3. Repetitiveness: Items like "building the test plan" repeat themselves for no particular reason.
   4. No examples: It's hard for the text to find any foundation in your mind when there are no examples to help the reader relate to. Given its monotonous descriptions, nothing could hinder the reader's efforts to understand and implement the book's ideas more than that.

   The final verdict: Look for another software testing book.




2. The book is full of hypothesis. Till now nobody would have implemented all the checklists/templates/procedures mentioned in this book, in their real environment and I can bet on this.

   Checklists are needed if the task of review/testing is very critical and the organizational processes shall demand that. An attempt to define a checklist/template to make it global is real childishness.

   The definition of Verification and Validation itself is written wrong in this book. I dont know if these terms had such definitions during the past years.

   Summary: We are in 2003 now. If somebody wants to go back to 1970 then this book will be very useful for them. A wise decision for normal readers would be to move away from this page. Thanks.




3. This is a very good book, despite what the other reviewers say. It is aimed at the professional software developer, consistent with good software engineering practices. Unfortunately, those who still work ad hoc in software development do not understand the value of formal processes and the resulting reduction of risk or increase in quality. This book assume that readers, and their organizations, have the required discipline to formalize their testing methods. One of the key principles in the book is that requirements must be validated and traced throughout the software life cycle - garbage in garbage out.

   Consider whether or not you would like to fly in a plane or have your bank account managed by software that has not been as rigorously tested as the author requires it to be.




4. Excellent book that covers testing in a lot of detail. It provides excellent ready to use test processes if you don't have any established already. Very comprehensive but you can still pick out the bits that are going to be of immediate value to your organisation. If you don't have a lot of experience you may need some help doing this though.
   
   Highly recommended



5. For several years, I have recommended Bill Perry's Effective Methods for Software Testing, 2nd Ed to people who are looking for testing processes they can customize and apply quickly. I have also included this book as a reference text in many of my testing courses. Obviously, I feel that the book is very helpful to software testers.
   
   In the third edition, there are two fewer chapters, but the coverage of topics has been revised to include areas such as agile testing, the role of testing in software development methodologies, testing internal controls, and an expanded discussion on security testing.
   
   The eleven-step testing process in the second edition has been streamlined to seven steps in this edition. In this process, you will find everything you need to design and customize your own testing process all the way from test planning, through the various phases of testing (static testing, unit testing, integration testing, system testing and acceptance testing), and even through post-implementation testing. The process also addresses analyzing and reporting test results, which also discusses test metrics.
   
   The reasons I'm such a fan of the book are: 1) You get complete templates and examples, including checklists (although the CD contains PDF versions of the forms which would still need to be re-created in a word processor to be usable in electronic format). 2) The book is process-oriented as opposed to a collection of techniques. Collections are fine, but you still need a way to apply them. That's where the processes come in helpful. Also, the workbench process framework is helpful in defining your own processes. 3) These are practical and proven processes that have been used in a variety of organizations worldwide. There is very little theory and a lot of practical application as shown by the examples. 4) You don't have to be a highly mature organization to start applying these techniques. Whether you are CMMi Level 1 or 5, you can still find this information useful. 5)The book also addresses specific topics such as testing commercial-off-the-shelf software and data warehouse applications.
   
   This is a thick book, but then again, it is not designed to be read from front to back. I use it as a desk reference and a collection of processes to help get the job of testing done. I can save hours of work in designing processes by checking here first. My attitude is to tailor the processes to meet my needs. It's also my first stop when doing research. Personally, I like processes because I can transfer them to others and have something tangible to study and improve. However, I will say that if you are "process averse" you will probably not find this book as helpful as someone who does process-based work. The processes described in the book are not heavy ones, though.
   
   This is a good resource for software testers written by someone who has been writing and working in this profession for many years.
   Readability - 4
   Coverage of topics - 5
   Depth of coverage - 5
   Credibility - 5
   Accuracy - 5
   Relevance to software quality - 5
   Overall - 5
   Reviewed by Randy Rice

5 comments about Microsoft Office Document Designer: Your Easy-to-Use Toolkit and Complete How-To Source for Professional-Quality Documents (Bpg-Other).

1. After purchasing this book over a month ago, I have attained the necessary tools and techniques to be able to create complex looking documents that weren't hard to create at all. The book was easy to read and the CD that was supplied had really great layouts that helped me put together some of the documents I needed for my job. Also the various toolbars were really helpful, so I didn't need to go searching; it was right there! After using Office 2003 / XP for quite some time I felt that something was missing...and this was it.



2. This book is like having an assistant to help with my documents. I create a lot of my own documents at work, and they have to look good. The book is a true help with that, not to mention the tools that come with the book. And, I can't believe how many how-to articles and tip sheets come along with the tools on the CD. Those articles are so great for quick and practical answers to the whatever I need to get done - I use them all the time.
   
   This is the first book on Office that's not a theoretical reference or a laundry list of all the stuff you can do but will probably never use. The book and the tools actually help me get my work done. The tools save a lot of time, and they help me do things I didn't think I could do (like complex page layouts in Word or formatting Excel charts). I think Office 2003 is great, but I can do a lot more with it since I started using this book.



3. I have trained over 3,000 people in Microsoft Word. None of them had ever heard of or used styles. Styles are necessary if you're going to use Word correctly. So, I bought this book for two reasons. First, I find that a woman writes a better book about learning software. I think women authors seem to explain software in better detail, especially for beginners. Second, the back cover describes a CD that has "Dozens of professional designs and layouts." I like examples for learning.
   
   So, I opened the book. It looked very good. Good topics, easy reading, nice coverage of Word, Excel,and PowerPoint. But, not a single reference to Word styles. Did I waste my time? No. I then looked at the CD and guess what? There is more information for Word users on the CD than in the book. Don't get me wrong - the book is good. But the CD has articles that explain more about how Word works than most people know. And as for styles, I found them when I loaded the samples, they were filled with styles. And, the CD tells much about their use.
   
   How about Excel and PowerPoint? They are also covered very well on the CD, along with great examples in the book.
   
   So, this book is about integration of three programs, yet each is covered very well. In today's world of business, if you know how, you can always find a job. You will learn the "how" with "Document Designer." You'll also learn the "why", and, if you know why, you can always be the boss.



4. I am a business consultant that works with Microsoft, HP, Oracle, HP, Xerox etc. and teaches how to conduct sales presentations to CXOs for a living. I can say that this book has taken the look, feel and ease of creating a first class executive level business case to a level I could have not imagined. At first it is quite daunting and overwhelming. But I had to get some business cases together for 50 marketing professionals in Sydney on a special workshop and I crashed into it. The MODD system once you "get it" is easy, fast and addictive. I ripped through Excel, PowerPoint and Word integrated data and information in no time flat with the MODD tools. It scared me it worked so well. This stuff is like awesome and it is refreshing to actually see a program work without a hitch. ( I wonder how they did that?)Krieger has made me look really, really good. Go for it!



5. This product's review suffers, perhaps, from my own expectations. I am an intermediate level user of Word. I was wanting to learn more advanced uses, especially document design.
   
   What this book/cd offers is a number of preset styles and some Word usage tips. I guess what I wanted was something to teach me more about document layout within MS Word.
   
   Basically, she's done all the work for me. While what she's done is quite good, I feel as if I'm dependent on her work; I don't feel I've learned much about how to do it myself.

5 comments about Metrics and Models in Software Quality Engineering (2nd Edition).

1. Solid information which not covers the basic development lifecycle and it's components but also the bigger picture e.g. predictive analyses, reflective metrics, customer satisfaction measurement, etc. A good read, informative and it won't scare a novice. Recommended.



2. This is one of the most highly regarded books on software quality. If you have never read the first edition it was one of the few books that covered software quality in depth, going well beyond metrics and models into strategies for achieving quality, and understanding the underlying principles and mechanics. That edition had a lot of life left in it, but this second edition is one of the most complete rewrites of any technical book I've read in recent memory, and if you own the first edition you may want to consider retiring it and investing in this edition.

   While the first edition packed a lot of information in 344 pages, the 560 pages that comprise this edition reflect new chapters and expanded content in the chapters that remain. Here is a list of the new chapters:

   - Chapter 10, In-Process Metrics for Software Testing
   - Chapter 12, Metrics and Lessons Learned for Object-Oriented Projects (in lieu of the old Chapter 12 titled AS/400 Quality Management)
   - Chapter 13, Availability Metrics
   - Chapter 15, Conducting In-Process Quality Assessments
   - Chapter 16, Conducting Software Project Assessments (the project assessment questionnaire example in the appendix is a valuable companion to this chapter)
   - Chapter 17, Dos and Don'ts of Software Process Improvement (contributed by Patrick O'Toole)
   - Chapter 18, Using Function Point Metrics to Measure Software Process Improvement (Contributed by Capers Jones)

   Among the new chapters I most like are Availability Metrics (Chapter 13), because of the direct tie to production, and Dos and Don'ts of Software Process Improvement (Chapter 17) because of the practical and objective advice. This book will remain, in my opinion, one of the definitive texts on software quality and is one I highly recommend.




3. As the System Test Team Leader for the Quality Technology area, I had to certify many of the tools and procedures used by Stephen Kan. Prior to that, as a System Administrator, I had to run software metrics on those tools, like those shown in table 6.3. As a design review moderator, I was charged with leading a number of IR, IE and I0 reviews.
   
   THIS STUFF WORKS!
   
   I can attest personally to the great effort and many find minds that worked together to develop and implement fine tools such as DCR, PTR, PTF and APAR, as well as the brilliantly simple, effective ways of implementing Continuous Quality Improvement techniques such as DPP. What Kan has written is real-world honest and true, not some academic exercise.
   
   Kan is dead-right on the money. If you want to track, predict and manage things in the real world, this is how you do it. At PSQT '97, Tom Gilb told me that SEI should create a new CMM "Level Six" designation for the way Kan and the others at IBM Rochester have dealt with software quality. That's how good the stuff in this book is.
   
   I am particularly impressed by how Kan has woven in not only his work and IBM Rochester as a whole, but also the work of others throughout the industry in such a simple, clear, easy to understand manner.
   
   Yet, given that the book is an easy read, that many of the techniques are easy to do, and that I see this book on the shelves of many IT managers, it baffles me why so few people and so few companies actually implement this stuff. I suspect that politics and corporate culture is what's holding back so many companies from enjoying the success, efficiency, and frankly the FUN of working in a continually measuring, continually refining work environment such as Kan describes.
   
   For example, Defect Removal Effectiveness is a very simple metric to gather. In a typical medium sized software company, or in the I.T. department of a large company, the head of testing and the head of phone support could easily enough get together and compare the number of bugs found in testing the last release with the number of bugs found in the field after that release was deployed. Both areas already have their problem logs, and if they can't directly pull counts and totals, it's typically only a few minutes work for the right programmer. So what's the hold up? It's not that the metric is hard to understand, or an academic exercise, or that the numbers are hard to get. It's that people have a hard time admitting that "their baby is ugly". The good of the company, stopping bugs from getting to the field, conflicts with the good of the testing manager, who doesn't want to risk admitting that problems got past them.
   
   Therefore, I think it would be a fine addition to this book if Kan could write another chapter which deals with the human side of the equation. The book thus far presumes an interest in software metrics and appropriate management support from the top levels down. What would move this book from worker's bookshelves to their desks, and keep this book open and used on a daily basis, would be some ideas on how to garner and build support for implementing software metrics and TQM practices across an organization. People want to do this; that's why this book gets sold. Unfortunately, people aren't empowered to do so, which is why many times this excellent book sits on a shelf.
   
   Paul Walchak



4. This book is a must have for all the managers and profesionals that need a complete and detailed reference for software metrics. It provides clear explanations and examples. It is very easy to read and very practical.



5. A very thorough treatment of Software Engineering metrics. Good graphics. Good explanations. Much better than other books in this area.

5 comments about Schaum's Outline of Programming With Fortran 77 (Schaum's Outlines).

1. My undergrad mech. eng. program uses MATLAB exclusively and I now need to learn FORTRAN for graduate school in less than a week. Despite the low rating for this book and knowing that it may be too elementary, I picked it up anyways just because of my experience with Schaum's outline.

   Indeed, this book is very elementary and doesn't addresses some of the problems that I might need to solve. But this book is an OUTLINE of programming in FORTRAN. I consider myself an experienced programmer (not expert, just experienced) and I'm halfway through this book in an hour. It shows me all I need to know before I start exploring FORTRAN myself.

   Overall, I think this book works like the owner manual for your car. You read it once then put it aside for a couple of years. But for $17, I think this is a very good buy. It will show you what you need to know fast. Just don't expect it to do your laundry and cook your dinner (dorm life humor).




2. This is a good resource manual for Fortran code builders. It has the basic resources that define Fortran concepts and syntax. No programming book can address specific problems you might be working with in code design, but the better books give you the foundations and tips necessary to keep you on track when using the language. I have found this manual helpful as it helps build code that will compile under all later version compilers.



3. This is a very good book for those who does not know programming with fortran 77 but would like to learn it in a relatively short period of time. It is also a good reference for those who writes fortran 77 codes and in need of a source to have a quick look at programming rules and examples. I used this book to write codes for my simulations in my PhD study. I recommend it.



4. For Fortran beginners this would be a good friend of yours but using it with other books such as Introduction to Fortran or other published tutorials on the web would put the icing to the cake.I recommend 'Interractive fortran 77- A hands on Approach' by Ian D Chivers et al.-which is also an online book to supplement this book.In that way you will be kickin' some fortran.



5. This book provides a basic outline of Fortran 77 for elementary programmers. I was previously only familiar with C++ (only one introductory class). This book helped me learn the basics of Fortran quickly and efficiently, but it does not cover any advanced topics.

5 comments about Object-Oriented Software Engineering: Using UML, Patterns and Java (2nd Edition).

1. The book is definitely a guide telling you how to do right thing in a right way. Good introduction to UML and show you how to prepare document for your customer.
   Highly recommend !!!



2. I'm currently following a Msc in Software Development in England. This book is very good. Finally an excellent source to go through in all its aspects. Examples as well as explanations are clear, sound, and solid. The book provides short, though detailed definitions that avoid verbose and useless comments. The book is guiding the reader through the explanation of how to carry out and accomplish a real project. What I mostly like is the heuristics given for identifing and setting forth all the artifacts needed during Requirements Elicitation and Analysis. Hat off to the authors of this great reference.



3. It is a highly readable book. The authors are good at explaining concepts with clarity.
   
   But the book is sloppy in any area that requires precision. They make no distinction of the four kinds of message sending in sequence diagrams. It is important for a UML user to differentiate synchronous, asynchronous, return and flat arrows. Otherwise a diagram will have different meaning. The authors use indiscriminately the notation of synchronous message when most of messages in their diagrams should be asynchronous.
   
   The coverage on OCL is even worse. More than half of the OCL constraints are wrong!!!
   
   You cannot rely on the corrections found on the authors' website because it only contains minor typos but misses the serious mistakes.
   
   Though it is more prescriptive than the standard software engineering books such as the ones by Pressman and Sommerville, I would NOT recommend its use as a textbook due to the many errors. I found "Object-oriented Systems Analysis and Design" by Bennett, McRobb and Farmer a better how-to book in software engineering.



4. This is NOT a book on Unified Modeling Language (UML). It's not a book on Object Constraint Language (OCL). It's also not a book on Capability Maturity Models (CMM), Class-Responsibilities-Collaborators (CRC) cards, Decision Representation Language (DRL), Extreme Programming (XP), Gantt charts, Issue-Based Information Systems (IBIS), Joint Appication Design (JAD), Key Process Areas (KPA), the Liskov Substitution Principle, Model-View-Controller (MVC) architectural styles, Nonfunctional Requirements (NFR) Frameworks, Object Design Documents (ODD), PERT charts, the Questions-Options-Criteria (QOC) model, Requirements Analysis Documents (RAD), Royce's methodology, Software Configuration Management Plans (SCMP), System Design Documents (SDD), Software Project Management Plans (SPMP), the Unified Software Development Process, User Manuals, V-Models, Work Breakdown Structures (WBS), or any of the myriad other tools introduced in the book.
   
   This IS a book to introduce newly-minted programmers to the kind of things, tools, and processes they can look forward to (with either anticipation or dread) in the real world of software development. As the authors state on page viii of the Preface:
   
   "We have observed that students are taught programming and software engineering techniques in isolation, often using small problems as examples. As a result, they are able to solve well-defined problems efficiently, but are overwhelmed by the complexity of their first real development experience, when many different techniques and tools need to be used and different people need to collaborate."
   
   It's been many years since I was involved in major software development projects (and those were all in the military). But, this book seems to have covered everything that all new programmers need to know so that they aren't simply lost when they enter their first software project. The readers certainly won't be experts in the things covered, but they'll at least have a good grounding and be able to bootstrap themselves from there (especially since the authors provide "Further Readings" and a Bibliography at the end of each chapter). For instance, on page 71, under Further Readings, they list three works on UML: one of which is the 566 page official specification, "OMG Unified Modeling Language Specification."
   
   Overall, this is an excellent book for anyone who is just entering the software development world. I rate it at 5 stars out of 5.
   
   As a side note, Florida State University (FSU) uses this book in its COP 3331: "Object-Oriented Analysis and Design" course.



5. This is not the best. You can probably can get something else that it is not that heavy to read. No good for rookies.

5 comments about Microsoft Systems Management Server 2003 Administrator's Companion: Administrator's Companion (Administrators Companion).

1. I am new to SMS and I must say that I now love it because of its power. This book made it easier for me to understand the ins and outs of the product. It will help you out a lot to know your windows environment well enough as well as your AD, after a couple of service packs SMS gets into deep waters. I would like to see the future editions of the book include chapters regarding free add ons such as the OSD Pack and ITMU, it would make it even better at least for admins looking for implementing it into a windows shop.



2. This book is wriiten with the expectation that you have working experience with SMS.



3. This book has helped me a lot with this horrible product from Microsoft. Needless to say, I've sold the book and I no longer bother with junky SMS. Still, a good book.



4. If you are new to SMS and you want to start working with this technology then this is not the right book. NOT because it is to complicated - more because it is way to detailed. But the book is great as a reference. I think it is even a must for a SMS admin. The topics are explained very clear and so far I found all the information I was looking for.
   
   If you are new to SMS and you want to start working with it I recommend use the SMS 2003 CBT Nugget and work additional with this book to get deeper into specific topics.
   
   But again - as a reference for you daily work this book is great.



5. After shipping 2 times from amazon. This book still didn't reach to me. Bad luck

4 comments about Practical Ruby for System Administration (Expert's Voice in Open Source).

1. If you've encountered Ruby primarily through Rails and know it chiefly as an elegant tool for writing web applications it's easy to miss its longer history as a tool for systems administration. Before Rails made Ruby the language-du-jour sysadmins bore much of the responsibility for keeping it alive, with the result that it has a suite of libraries helpful for server monitoring and a range of other administrative tasks.
   
   Author André Ben Hamou is clear that his book is not an exhaustive guide to using Ruby for systems administration. Rather than try to cover every possible context he provides an introduction to the language and some of its key libraries intended to give a feel for how it might be used and why it leads to succinct and expressive solutions. A number of the more important libraries for working with network protocols and files are covered, and there's a good introduction to rubygems and how they can be used and created.
   
   Having not done much work with Ruby on the command line I found the first couple of chapters, which cover command-line switches that can help with one-liners for file processing, particularly informative, though I suspect I'll be referring back to them for a while until the different options take hold. As with the book as a whole those chapters are clear and to-the-point, helped by a presumption that the reader has a good understanding of the problem space and some experience with using scripting languages to simplify their life.
   
   Don't go into this book expecting to come away ready to work as a sysadmin. That's not its intention. Nor is it a comprehensive guide to ruby, and you'll probably still want a good language reference to go with it. But it provides a number of helpful hints and a good sense of how robust scripts can be built quickly and simply with ruby, and there are likely to be a few helpful tricks for most readers.
   
   Disclaimer: I was sent a copy of this book for review by the publisher.



2. I thought this book would be great for me since I am a Unix administrator still relatively new to Ruby. I was right. This book covers a wide variety of topics, from ActiveRecord, to parsing XML and several other normal administration tasks. (network programming, ssh, monitoring) The depth of the coverage is more than adequate in most places. I learned quite a bit about using Ruby to automate some tasks, and of equal importance, I learned about the infrastructure behind ruby. He reviews performance, documentation, rake, rdoc, gems and more.
   
   The book is a great length for system admins who are not hard-core developers, but looking to expand their skillset and get some real benefit quickly. The coverage of XML-RPC, and ActiveLDAP, I have already put to use.
   
   Besides having some really strong content, the delivery in this book is great. The author commonly sounds like a system admin just talking to his buddies at a bar. The quotes and fun sayings are numerous throughout, but this was my favorite.
   
   When talking about the confusing terminology use with ldap, (cn, ou, dc etc) he takes a two step approach.
   1. Use Wikipedia
   2. (Direct Quote) "Whenever anyone suggests continuing use/support/deployment of LDAP solutions, laugh in their face with such explosive force that your response may be easily interpreted as an act of war. "
   
   Disclaimer, the author thoroughly covers LDAP, and clearly understands it, it was just funny.
   
   I laughed out loud reading this book no less than a dozen times, which is rare with a technical book. If your interested in Ruby, check it out. You won't walk away an expert, but you will have a better understanding of Ruby and its usage.



3. This isn't a bad book! There is coverage of LDAP, database processing with ActiveRecord, XML parsing and a number of tools that sys admins and developers who administer their own dev environment routinely use. The section on network monitoring as well as the Chapter on single liners for Ruby Sys Admins are worth the cover price for the book. However, I was a bit disappointed with the lack of coverage in some areas where the author introduced a basic concept at a level too basic for experienced users and then palmed off the user to a reference site for some more reading. There isn't a problem with this approach it is just that it happens a bit too much throughout the book. Perhaps the coverage was a bit ambitious and some of the more in-depth material was left out?
   
   Anyway, that's pretty much the reason for me not giving it 4 stars. However, do take a look at the one-liners, they are definitely going to save you time!
   
   Oh, the actual writing style is quite fresh and informative. You are not likely to get bored with this one... Overall I am still happy to have got my hands on it, but it wasn't exactly what I was led to believe from reading the other reviews.



4. The title just doesn't do this book justice. Yes, there's some sysadmin bent, but most of the discussion is much more broadly applicable -- it isn't just sysadmins who care about writing clean code, storing data in the cloud, LDAP, safe file handling, dsls, SOAP, graphing, etc etc etc.
   
   Plus Hamou is really funny in his own way. This book reminds of K&R or the Perl Camel book -- it is written in a conversational tone, with valuable gems (no pun intended) mentioned in passing.
   
   5 stars.