5 comments about Object Design: Roles, Responsibilities, and Collaborations (Addison-Wesley Object Technologiey Series).

1. Overall very good impression, original presentation with sidebar essential quotes. However after a while seems more of the same: how to identify collaborations in an Object Oriented Design. Special note for Chapter 8, where valuable and interesting information is provided regarding exceptions and errors.



2. I am a developer/programmer for a technical software company and my review contains my perception of this book from that perspective. I must also disclose that I am sceptical of any object-oriented design methodology that involves a lot of writing. We are "programmers", not story writers (read use cases).
   
   When I ordered this book a week ago, I couldn't wait to get my hands on this book because it sounded so promising. My enthusiasm turned into total disappointment so quickly I couldn't believe myself; I had to give another shot in reading this book to make sure. But I am convinced; the authors managed the impossible task of filling its 390 pages without saying anything substantial about object-oriented design for a professional software developer.
   
   The book might be useful for a novice programmer or a manager in terms of defining the object design jargon and process. But other than this, it provides no valuable advice for a professional. These are some of the points that I find ridiculously simplistic and almost idiotic:
   
   - In my opinion use cases and CRC cards all boil down to writing on a piece of paper what classes one should use and what these classes should do. This is not methodology, it is common sense. Any sensible developer would write down his/her ideas about the classes involved in an application before starting to program.
   
   - Although it is valuable advice to think about class responsibilities, the book states nothing more than the obvious in terms of finding what responsibilities should be assigned to which classes. Statements like "Responsibilities come from statements or implications of system behavior found in use cases" are tautologies. Where else would they come from!
   
   - Or the chapter on Flexibility says things like "Find out what you don't know". I can't even begin to elaborate on philosophical implications of such advice!
   
   Although the book looks appealing to the eye, it has no clear content. It states ideas about classes, responsibilities, etc without a clear structure; and after a while, everything said seems to be a repetition of some earlier statements.
   
   If you are serious about object-oriented design as a "programmer" I recommend these three books:
   
   1. Gamma E., et al., Design Patterns.
   2. James R Rumbaugh, et al., Object-Oriented Modeling and Design. A bit dated, but you will get all you need to know about object oriented design from this book.
   3. Bjarne Stroustrup, The C++ Programming Language (Special 3rd Edition). Never mind it is a C++ book. Chapters on OOD (I think chapters 21-25) will tell you exactly what you need to understand to start programming using OO approach.
   
   Do yourself a favor and invest in these books; and ignore all the fab about such trendy books such as the one reviewed above.



3. I have read so many OOAD books, none of which give me a clear idea how and why software design should be designed that way,
   at which situration, according to which external facts should the correct design decision be selected and considered.
   In core OO design stream, we will distributed/assigned each object with their desirable responsibilities, we must select a flexible control and coordation style to allow software for change. it is a system view of our software.
   
   This book given me a best introduction to think a solution all above questions and design views(system behavours).
   When I read and studies this book, it let me consolid and remenber many knowledge above control theory, layer architecture of big software system such as CAD system.
   
   Each project have particular siturations and design constraints,
   how we can design a useful software to solve user requirements is the first thing to consider.
   
   Many formal formalism will not be work for flexiblity, such as RUP CMMI... etc, those processes like a doing documentation not a useful design and devlivery working software that fit our users requests. I think experience programmer, developer should more thinking in system point of view.



4. The authors provides a good introduction to object oriented analysis and design. Some may find that the content is too wishy washy with seemingly vague advice in many areas. The responsibility driven approach along with object stereotypes are indeed a good way to approach OO design however. The concept of object neighborhood and control style are also worthy of praise.
   
   If the reader persists they'll be rewarded with a good understanding of why OO design is needed. There are nuggets of wisdom throughout the book, however many sections seem to be hastily done and glossed over. Too many times the authors resort to bullet listings to explain concepts. That may be acceptable in today's power point age but its not acceptable for a technical book. Reading lists after lists of advice is not a good way to learn and retain concepts.



5. I have to agree with some earlier reviews on this book.
   1. Very Good Text on Object Design,
   2. A great first text on OO design,
   3. Total Disappointment for Programmers
   
   This is a great book on Object Oriented Design, but ONLY for novice and intermediate object modelers. It is not for an experienced developer who already knows how to use some of the design patterns in Gang of Four book.
   
   If we use an analogy to compare this two books, if Gang of Four Design Pattern book is for post graduate students, Object Design is for the student in the second year of the university.
   
   I want to read more on Object Oriented development so I started to read this book, mainly attracted by its cover. Domain Driven Design by Eric Avans falls into the same category but offers much more exercise for your brain.
   
   Hope this is helpful. I have 10+ years in software development, 7+ years in Java, understand OO and Domain Driven Design.
   
   5 Star Book for a beginner.

5 comments about Software Testing and Continuous Quality Improvement, Second Edition.

1. You'd have to download over a gigabyte of internet resources, then cross-reference them to come anywhere close to having a resource as valuable as this book. Lewis has taken proven techniques spanning both software testing and SQA, wrapped them into a quality process based on the PDCA model and places all of the information you need to master testing and SQA between the covers of this outstanding book.

   All you need to add is the ability to think. If you can do that you'll be able to transform the incredible amount of information in this book into action. If you do that I guarantee you that you'll be able to develop a world class quality organization.

   Of course, you can mine the publicly available resources and sort through them. Before you do, think carefully about how much your time is worth and just how much you can absorb. If you're intelligent enough to understand this book, you'll quickly see that you'll save thousands of manhours. If not, you still need this book because approach will make you think in terms of cost/benefit.

   The forms and checklists in this book alone are worth many times the price.




2. This book represents the most complete and comprehensive approach to total quality of any I've read on either software testing or software quality assurance.

   Highlights include:

   - A structured quality cycle based on Plan-Do-Check-Act. This cycle is the foundation of continuous improvement, which is the theme of the book.

   - Complete description of testing techniques - in this respect the book is an encyclopedia for software test professionals and a definitive reference.

   - Comprehensive resource for forms and checklists (I wish these were also provided in soft copy on a CD ROM or author's web site, but they are not).

   - Full view of metrics across every aspect of the development life cycle. In the same manner that the testing techniques are encyclopedic, the metrics are also an encyclopedia for SQA professionals.

   I've used this book as a reference, and it had a heavy influence on a reference chart a colleague and I developed for depicting life cycle key metrics. It does not confine itself to testing alone, and in fact, has something for production services and service delivery professionals, as well as project managers involved with large scale development and implementation projects. You would have to buy at least a dozen books or download thousands of documents off the Internet to get the information contained between the covers of this book.




3. I have used the 1st edition for years as my primary Test & QA reference. Being a fan of Dr. Demming, this book supports his teaching. Mr. Lewis's book provides many pracical examples and templates for the QA practitioner, be they a seasoned pro or someone just thrown into Testing for the first time.



4. 
   Don't believe any of the positive reviews. This is a horrible book.
   
   The material is very scattered and incoherent, and it is incredibly repetitive. Virtually complete paragraphs are repeated at different points throughout the book. The book reads more like a poorly written report than a textbook. In fact, like a report, the book is composed of "sections" and "parts", where a section corresponds to what would normally be a part in a regular textbook, and a part corresponds to what you would normally call a chapter.
   
   The author devotes an entire chapter (sorry, "part") to discussing software testing in a spiral development environment, yet makes no mention of agile development methodologies or test-driven development. For a book that was published as recently as 2005, this is an unacceptable omission.
   
   The book's index is anemic. The index entries under the letter 'I' include "In God we trust" (a reference to an irrelevant comment in the introduction) but makes no mention of "Integration Testing". In a book about software testing, this is absolutely ridiculous.
   
   The level of detail in the book is also very inconsistent. Take the appendices as an example. Most of the appendices are less than a single page in length. There is one illustrative example of a software program that is used repeatedly throughout many of the appendices. The program is a primitive little example sketched out in about a dozen lines of pseudocode. You won't find any real-world source code in this book. Then, you have appendix G11, which includes a detailed introduction to relational databases for the absolute beginner. This was a very sudden and drastic change of pace, from glossing over all technical details and forgoing any discussion of real-world technologies, into a full-fledged tutorial.
   
   For an example of the kind of meaningless drivel you'll read in Lewis' book, take a look at this paragraph from page 253:
   
   "Of the various activities in the project plan, planning and execution are the key activities that determine the cost of resources and schedules required for the testing projects. During these two crucial phases of testing, various key deliverables are estimated. This will ensure that the test team will have a focused approach and the delivery of the deliverables will come to a logical end so that the project can proceed with the next task in the plan."
   
   If this makes any sense to you at all, then I congratulate you for mastering the fine art of semantic and syntactic redundancy while delivering virtually no value to the reader. A bright career in consulting awaits you.



5. Very poorly structured and poorly written book. It seems outdated considering it centers around the Waterfall development method.
   
   Unfortunately, this book was a requirement for my course, otherwise I would return it. It is by far the worst text book I have had to read in my studies.
   
   A note to prospective buyers: Keep in mind that (almost) all the positive reviews are over 6 years old and the negative reviews are recent. A lot seems to have happened in software development methodologies (including SQA) since that time!
   
   Hopefully, the forthcoming third edition is better but it requires a serious re-write.

5 comments about Beginning Spring Framework 2.

1. It is a good book for beginners. It teaches you how to hands on code. The example is step-by-step. It answers lots question to a beginner. It is the best readable book I recommend to beginner.



2. Before reading I have made use of the Spring Framework (others did initial configuration) but never fully understood how it worked. This book helped explain features I did not fully understand and reinforced concepts I was familiar with. My current project utilizes Spring and this book jump-started our use of Ajax, DAOs, and Web Services. Easy-to-understand language and very readable.



3. This book is perfect for me. I've suffered through heavyweight J2EE projects in years past, worked extensively on Struts servlet-only apps, and spent the last year building a Ruby/Rails application. Now I gotta ramp up for a Spring project and I need a book tailored to getting me started in Spring quickly. This book does that.
   
   The focus is on getting an experienced developer up and running in Spring. I know I can backfill knowledge of Spring internals later with one of those 700 page books. I like that in addition to developing with Spring it ties in most of the nuts and bolts of project development - unit testing, build management, and Spring-specific eclipse IDE navigation.
   
   There's a couple of niggly problems getting set up with maven, a resource location, and a .jpg file, but by simply going to the book's forum on wrox I had that all resolved in less than 15 minutes.



4. I feel this book could have been good because the authors attempt a broad-sweeping introduction in a short and to-the-point manner. Sadly, however, I gave up on this book when I realized the authors/editors hadn't gone through and unit-tested each chapter's code and content for reasonable logical soundness from a pedagogical perspective. I ran into issues running simple tests because data tables were not created in the outlined setup process. More than just the issues with the code though, I felt from the onset that the authors did a poor job with the writing itself. These guys gloss over some concepts as if in haste to complete the book. The authors and editors, I feel, just did a poor job of creating an effective instructional instrument. To further its demise, the book's forum is poorly supported by the authors. There are barely any solutions to posted problems and the readers are struggling to help themselves one bug at a time with the poorly tested code and book instructions. I am of the frame of mind that learning a framework should be fun and interesting. The shoddy editorial work on this book makes learning painful and agonizingly annoying. Onto a better book for me...



5. While the book is excellent and informative, in typical wrox fashion they don't include the complete source code on their download. So I'd definitely give the book 5 stars but lacking the source code, and the fact the compilation fails in maven, has to bring the score down.

1 comments about Beginning Web Development, Silverlight, and ASP.NET AJAX: From Novice to Professional (Beginning from Novice to Professional).

1. This book is a good start for anyone who wants a quick overview of web technologies as offered by Microsoft. Roughly one-third of the book is dedicated to what would nowadays be called "traditional" web technologies based on ASP.NET. It covers a lot of areas (Web forms, ADO.NET, Web Services, deployment), but never dives very deep. The second part focuses on the Next Generation technologies for Web Development and provides an introduction to WCF, WPF, WWF, Cardspace, Ajax, APS.NET AJAX and Silverlight. Unfortunately, it only addresses Silverlight 1.0 and some interesting new developments such as LINQ and project Astoria are left out completely.
   
   I noticed quite some errors in the code examples in the book (especially in the first part), which I think should have been picked up by the reviewer.
   
   All in all, an interesting read that will certainly make the user want to visit Amazon for some more in-depth books on one or more of the many topics they've just become acquainted with.

5 comments about AdvancED DOM Scripting: Dynamic Web Design Techniques (Advanced).

1. This is truly a next generation book for building software on the web. There is nothing like it anywhere else. If you want to add the functionality, scalability, accessibility and the inevitable "bling of web 2.0", then you NEED to buy this book.
   
   Jeff's writing style and tone in this book are perfect. He makes complicated topics simple and intuitive and presents real-world examples you can use today.
   
   Only Caution: Don't buy this if you're a beginner (it's an AdvancED book for a reason). You'll want a good understanding of CSS, Javascript and HTML to get the most out of this book. All professional web software engineers will want this book close by 24/7.



2. The author clearly knows his stuff but I find the book hard to understand. Is it the author or my level of javascript experience? Hard to say. I will say this - you probably want to know javascript very well before getting this book. For those taking learning steps in javascript like myself, this book is far from the next step from Jeremy Keith's books.



3. UPDATE (3-17-08)
   
   I bought this book again because the material is definitely good. I'm really bummed Friends Of Ed let it go to press with all these errors though. I mean, come on--I'm finding errors all over the place! That is a great disservice to Sambells. But I've decided the material is worth wading through the many, many copy editing oversights. I'm crossing my fingers I don't get stuck troubleshooting typos in the code that choke my browser. That could easily waste hours of my time.
   -=-=-
   
   I was pretty excited after I dropped the $50 or so to by this book because the contents are right down my alley. Unfortunately, I could hardly make it out of Chapter 1 for all the typos and editorial oversights. Here are a few as an example:
   
   PG 34 -- "myVarialbe" instead of "myVariable"
   PG 35 -- "when you retrieving" instead of "when you are retrieving"
   PG 36 -- references a function called "initAchors()" that isn't used in the example code for that example. initAnchors() appears in the next example on the next page.
   PG 37 -- number of iterations in loop changes from 3 to 5 from 1st example to 2nd example for no apparent reason - this is confusing and distracts from the point being made.
   PG 37 -- Figure 1-7 shows three objects in diagram instead of the 5 needed (one for each loop)
   
   This is all in just 3 pages!
   
   This is the part of the book I started reading first so I assume the rest of the book is going to be as poorly edited/ proofread. This surprises me as I own over 5 or 6 titles from the Friend Of Ed series and I don't recall ever seeing so much as a typo in any of them.
   
   Overall, I think the book shows promise. But I can't tolerate errors like this in a programming book. They are difficult enough to read already without having to figure out what the message was "supposed" to be.
   
   I'm returning this book to the store. When it reaches a later edition I may give it another go. It needs some serious "debuggin" first though.



4. This is the greatest Modern JavaScript, DOM Scripting, and AJAX book I've ever seen. Having done AJAX since 1999 before the buzzword ever became popular, I can say that a book this exhaustive has never been written before now. It covers everything from the JavaScript's often misunderstood variable scope to the deep interaction with the DOM and everything in between.
   
   This book is an intermediate to advanced book that requires that you have some understanding of our every day web technologies. If you are a web developer, then you are required to know XHTML and JavaScript anyway. This isn't just some surace level "how-to" book. This covers the deep internals of AJAX and will make you an expert.
   
   Feel free to ignore anyone who claims this book contains spelling errors or other things that in no way change the overall structure of the book and that any thinking person can get around. No ant will ever make a sky scraper fall; it's irrelevant. This isn't an English book or a book for novices. It's a practically graduate-level JavaScript/DOM/AJAX book that requires you to be a thinking person to begin with.



5. If you already know a lot about scripting it is probably a brilliant book but do not attempt to read it as a newbie.
   I am not new to scripting but I found most of it too advanced - The parts I could follow had great solutions and suggestions though.

5 comments about Software Test Automation (ACM Press).

1. I bought this book because I was new to software quality assurance, yet placed in charge of an automated testing effort. This book clearly encapsulates years of experience -- you can almost feel the pain the authors must have experienced as they learned these lessons the hard way! I have already avoided making a number of mistakes.

   The authors organized the material effectively and wrote it in a way that promotes skimming and scanning. By reading the first few sentences of a section, you will know whether you are interested in the section. If you're not interested, skip to the next section. The authors even occasionally tell you what sections you can skip should that material not apply to your situation.

   These skimming and scanning aids are important because the text itself is frequently unexciting and cumbersome. There's not much to do about the former -- nuts and bolts are hard to make exciting. I hope, however, that the authors will consider a good edit for more vigorous writing should they update this book for a second edition.




2. I found this book to be a solid roundup of good practices within automated software testing.

   It doesn't provide any startling new techniques, but makes a good job of explaining the common pitfalls that are usually encountered when trying to automate testcases, and provides good advice for how to get the best out of commercial tools such as the one available from julianjones.com.

   The writing style can be a bit dry, and there are times when the thought of reading 500 pages can be a bit daunting.

   All things considered, highly recommended.




3. Hi
   This book deals with various issues of Automation such
   as basic concepts, impelementation details. It has various
   case studies also. A must for those who are considering
   for testing automation.
   It should have more coverage for data driven automation.
   [Niteen]



4. The book theoritically explains testing in great detail.It would have been an awesome book if it had a software part to it.Lack of software makes the learning experience incomplete but still the book is worth the money.



5. I've written code that shipped in 1 to 2 million units. I also did an academic post-doc in computer science at a good university.
   
   Testing is not just underappreciated in the academic community it is widely misunderstood. Academicians are fascinated by questions like how do you create a program to test your programs. By comparison the automation of human designed tests is not academically worthy. But this is most of what separates commercial grade code from research code. It is what creates 99% of the economic value of testing. And done well it elevates the status of testing from clerical work to top-tier design work. This book explains why this is true. Armed with that insight, a skilled technologist will be able to work through the rest of the details.
   
   Nevertheless, the book offers quite a few recipes. None of which can be implemented without a skilled technologist capable of working without a recipe, but all of which enhance the value of the book.
   
   Really a rare gem.

No comments about Essentials of System Analysis and Design (3rd Edition).

5 comments about Object-Oriented Design Heuristics.

1. I have plenty of books on patterns, but I want to get more information on the basics of OOP and why the patterns are effective instead of "this is pattern X, and this what it does." This is a very complicated subject, which I have no doubt that most programmers on the planet have very little understanding of. We mostly write crummy code that "works", and most of the time that's good enough.
   
   I was uncertain about getting this book because of how old it was, but after reading most of it, I'm happy I got it. Although complex, it is written in an understandable manner with useful diagrams. I wasn't as interested in the "one-liner" heuristics as I was the detailed explanations of the problems caused by particular design mistakes and the other examples and pitfalls presented.



2. I have been studying the object oriented methodology for some time now. I felt that I had a good understanding of what OOP was all about. I have studied OOA/D and design patterns from numerous sources. All of my sense for OOA/D knowledge changed completely when I read this book. This book really showed me that I was stuck somewhere in the middle of the paradigm shift between action oriented programming (aka procedural programming) and object oriented programming. After reading this, I feel like my knowledge in OOA/D has truly advanced to the next level.
   
   Are you the type of person that knows what OOP is? I mean, if you've studied up on OOP then you are probably aware of what an abstract class is. You know what interfaces, inheritance, polymorphism, information hiding (...etc) are. You may have a sense in when you should use inheritance and when you should use containment. You probably follow certain OOP practices like keeping all of your variables private, hiding secrets from other objects (information hiding). This may all make sense to you but are you also the type of person that just never feels comfortable about your designs? Do you look at your classes and just get a sense that something doesn't seem right, yet you just can't figure out what it is even if your software system is running fine? I am willing to wager that you are in the middle of a paradigm shift. You are probably taking the route that a lot of developers take when they shift from thinking in a procedural fashion (action-oriented design) into object oriented design. There is nothing wrong with this, but if you're like a lot of developers you will have a long hard journey utilizing a lot of experience before you really make that shift. This book is an essential tool that will help you make that shift a LOT faster. After reading this book you will see why you felt your designs were't quite right.
   
   One of the first topics that really hit home for me was when the author Arthur Riel talks about God classes in chapter 3. God classes are classes that have too much implementation in them. Most of the complexity of a piece of software resides in these classes. They are the all-knowing classes that delegate messages between the much smaller, less complex classes. Signs of God classes are classes that have words in their name such as "Manager" or "System" in them. This one hit home because there are numerous classes in the software i'm working on now with the name Manager in them. For example one of our classes is called the "BiDirectional_Dataflow_Manager". This is definitely a God class through and through. While I was reading about the disadvantages of these types of classes I couldn't help but agree with everything Arthur was saying. I began to see the light already and I was just on chapter 3. There are 59 other Heuristics, all equally important in this book.
   
   Most books that teach OOA/D seem to really only teach the definition of OOA/D and perhaps clue you in to the whole idea. You learn the terminology well and you see a few examples (I'm sure you've seen an animal hierarchy a time or two), but you don't really gain a solid understanding in how you actually think in objects. This book will bridge that gap. This is the best book i've read by far on OOA/D. This book will apply to you no matter what your skill level is in OOA/D, unless you're a complete beginner then you might find yourself a little bit lost. If you are brand new to OOA/D then you should probably read a short book on OOP, just to gain the basic concepts first. "Object Oriented Thought Process" might be a good start as it's short and sweet, then you should move on to this book. If you are advanced then you may know a lot of this information, but this book will probably help tweak your OOA/D skills; helping you become an even more solid developer. But for you guys and gals out there that know what OOP is and read a few books on it, but still don't feel quite right about your designs, this book is essential. You guys out there are the sweet spot for a book like this. That's how I was. Now I feel so much better, I feel like i've gained more knowledge in OOA/D with this book then all other books on OOA/D and OOP that i've read combined - and then some.
   
   Arthur Riel is a very talented programmer and author. He is able to communicate ideas to you that are sure to hit home, as if he's right there with you and understands your problems in OOA/D. This book is densly packed. Not including the bibliography and index this book is a mere 367 pages. Even more, if you don't include the example code at the end of the book (all C++ code) this book is only 243 pages. The real meat of this book is in the first 9 chapters (where he talks about all of the heuristics), which totals 182 pages. After that he talks about topics such as handling memory leaks and such. Most of the dim lights will shine brightly after a mere 182 pages! This may sound too good to be true, but as I said earlier Arthur is VERY talented in communicating his ideas. You just have to read this book very carefully, don't skim! Because it's so dense, it may take a couple of passes before you really get the idea but once you understand it you will surely belt out a resounding "AH HA!". This book is 10 years old at the time of this review, but the information inside is far from being outdated.
   
   To conclude this lengthy review (sorry about that) I would like to say that I give this book my highest recommendation. In fact, this may be the best book on software development that i've ever read! This book has influenced my software development more then any other book i've read and that's a fact. This is truly a rare gem. The only downside (not this books fault) is that it's become a bit harder to work on the software that i'm currently working with because I now see where all of the pitfalls are. My co-workers think i'm just being anal about design now, but you don't have to be like them. Step up, become the best software developer that you can be. Just read this book and you will take a giant leap forward in your OOA/D understanding, especially if you're stuck in a paradigm shift like I was. Thank you very much Arthur!



3. OO design and analysis is so very gray. No book can cover every aspect because the possibilities are endless. Everyone's application and environment is different which causes each and every one of us to approach our design differently and value different affects of our coding practices. By far this is the best book I have read that simply lays out OO rules-of-thumb and then explains why each is beneficial and when they might contradict other rules-of-thumb. The book encourages the reader to be reasonable and practical in your application of OO best practices.
   
   I strongly recommend that every development team read this book and discuss it amongst themselves.



4. Ok, I had to look up heuristics in the dictionary before buying this. But other than that I found this to be one of only a handful I've read that tells you how to look at OOD work you've done and decide if it is good (and how to improve it). Particularly good was the discussion of cases where design goals conflict and how to resolve the conflict.



5. Regrettably, I disagree with the other reviewers here who seem to have liked this book. I didn't. Not that it's terrible: I found myself in agreement with most if not all of the rules of thumb the author talks about; the problem is more that this book is not well done.
   
   First, this is a textbook; as such it is aimed at a student, that is someone who doesn't know the material yet and tries to learn. But for a tutorial this text overwordy and imprecise, with a generous quantity of confusing, misleading metaphors. If you happen to know what the author is trying to say, then you sorta get it -- I mean, you get it 'cause you already know it -- but a newcomer will be confused.
   
   Sometimes the author doesn't seem to know why a particular rule is good, so he goes something like this: rule such-and-such is good because most software engineers would agree that it's good. I doubt the author conducted a statistically valid survey -- but forget that, suppose most software engineers do in fact agree: so what? All the author has now is a nice and juicy ad populum. But he, obviously, isn't even aware that something's wrong -- and that may be one of the problems with this book: the author may not be experienced enough to write books of this sort. He may be a competent practitioner, but this is not the same as teacher.
   
   He tries to compensate via an over-abstract and smart-sounding terminology (one of the reviewers below jokingly complains that he needed to look up the word "heuristics": that is a telling comment, and it is valid. I, too, noticed that the author takes delight in using a dozen hifalutin words where one simple word would do (and result in a clearer text).
   
   Riel also likes to belabour commonplace excessively ("data should be hidden inside objects"; "Objects should not depend on their users", blah-blah, brush teeth daily, apple a day etc.), anything to make the book thicker -- which brings me to its second defect, less important and quite a common one today: the book is blatantly padded. Out of about 400 pages only about 200 have readable text; the rest is mostly a source code printout (this code could have been supplied on an attached disk or put on the net somewhere). There's also a few pages with a concise restatement of the author's rules, which could have been printed on the cover insides (like in the Stevens network books) or supplied as a pullout; otherwise this list is hard to find and serves no purpose.
   
   To summarize: were it better written, Heuristics could be useful for a newbie, but it's not and so it isn't. A more experienced reader, despite being annoyed, will understand it -- but only because he already knows the stuff himself and will be recognizing rather than learning. YMMV, but in my opinion this tome isn't worth reading time for any reader, new or experienced. I'm sending it back.

2 comments about GO Series: Getting Started with Microsoft Office 2003 (Go Series for Microsoft Office 2003).

1. It's a first edition, and it shows. Full of errors, typos. Good first attempt, but not ready for prime time.



2. If you intend to use this book in school, buy it NEW. The License key that gives you access to the website for the class assigned tests is not transferrable or renewable. You cannot buy the license separately. I know, I bought this used for class and had to buy a new one even after calling Prentice Hall. They told me that they sell keys separately on some of their books, but not all of them. Also, if you still are buying it used, make sure it contains the 3 CDs that you will need.
   
   Overall, it's a very very basic book for someone who has little Microsoft exposure or is not computer literate. The office examples are thorough, but give only the basics. I'd give this book to my grandfather who doesn't like computers, or to a friend who is a Mac user.

1 comments about The Definitive Guide to SUSE Linux Enterprise Server (Definitive Guide).

1. WOW! I was reluctant to buy a cover-all-bases kind of administration book on the assumption that not enough detail would resolve through each chapter to be of any real value. Was I wrong!!!
   
   As a novice systems administrator trying to migrate a Windows SBS 2003 system to Linux, the only feasible option (for me - a newbie to Linux) seemed to be SuSE Linux Enterprise Server 10, and a quick search of Amazon only revealed one generic administration book targeted at SLES. Not sure of just how detailed the chapters would be on Samba & LDAP (the topics most relevant to me), I acquired this book along side the purchase of some other books which dealt with those topics specifically.
   
   Assuming that I needed hardcore LDAP and Samba books to help with Windows XP authentication and folder redirection over a Linux server network was a mistake. After reading most of this book already, I think I can safely resell my Samba and LDAP specific titles on the premise that I don't need them to facilitate the aforementioned resources. The only other MUST-HAVE book which has been made use of extensively in my transition is, Windows and Linux Integration: Hands-on Solutions for a Mixed Environment Check it out...
   
   Obviously not a book that goes into reams of details about any certain event of course, however, there is a balance of screenshots and line-by-line walkthroughs that fill this book with a practical value I have not seen in other Linux guides. Chapters are ordered and versed so well that I read this book from front to back in chapter order as easy as reading a good novel, and I still felt like I was making educational progress from every page.
   
   In conclusion, I must recommend this book for those with limited Linux experience who have decided to give SuSE a try on the assumption that this may well be the most user-friendly introduction to Linux server administration. You won't be disappointed with this combination. Some of the features of YaST are self-explanatory as they are, but with this book as a guide, one just can't go wrong.
   
   Do yourself a favour and purchase this book BEFORE investing money on others (like I did), THEN-AND-ONLY-THEN should you assess whether you need more detail/less spending money. For a generic administration book, this is a must have.