5 comments about xUnit Test Patterns: Refactoring Test Code (The Addison-Wesley Signature Series).

1. We went over 2,000 unit tests this past week during Iteration 72 on our Agile project. Of course, over the course of the last 18-24 months we have removed some tests, and in many cases, refactored the existing tests many times. We also have been learning a whole lot about TDD and the actual domain that we are building and testing. As we were doing this, we were implicitly discovering Test Smells, and discovering test automation patterns. The value in establishing patterns, and more precisely a pattern language in a particular domain are substantial. It's not so much that the "collector" of patterns is defining something new (some often mistakenly criticize pattern books in that regard) that you didn't know, but defining a shared terminology of our practices that we keep doing over and over. To that end, the patterns themselves not only define a shared vocabulary but serve other functions, not the least of which is learning from others. An obvious example of this is Martin's PEAA collection of patterns that enables us to say things like PageController or Lazy Load or TableDataGateway and we all know what it means. In fact, when I am talking about Interaction versus State/Behavior type of testing on CB, and others here use much of this terminology, I am in fact, talking about patterns like TestDoubles and MockObjects, among others.
   
   When I became aware that Gerard Meszaros ' xUnit Test Patterns book was going to ship Friday, I ordered it for overnight delivery on Saturday. I read well over 200 pages yesterday pretty much at one sitting, contented with a book that will change the face of the software industry, just as JUnit and all the other xUnit family have fundamentally altered software development for the better. Its definitely a big book at 944 pages, but it's not a book of excess, unnecessary pages. Rather it shows how hard it is to write defect-free software and the depth of the work that people are putting into this endeavor. The book uses Java as the language which obviously is no hardship to the C# programmer. Like most of the sound practices that have been evolving in the last ten years, this work has been evolving out of the terrific Java community.
   
   Just like their are Code Smells, there are Test Smells, and writing good test code is just as hard and as worthy as writing good production code. Meszaros categorizes Test Smells into ProjectSmells, BehaviorSmells, and CodeSmells. Particularly interesting is his discussion in this regard to the commercial "record and playback" test automation products that have given test automation a bad name in many circles with their tendency to create FragileTests particularly with regard to Interface Sensitivity. Like many others, we were drawn in, and spent and wasted thousands of dollars with a vendor and exhibiting extreme Interface Sensitivity with the user interface. Their interface was not only unable to "pick up" most of the controls we use but even minor changes to the interface can cause tests to fail, even in circumstances in which a human user would say the test should pass. This only goes to support the notion many of us have talked about here about factoring a UI into MVP or MVC and not having logic in the "presentation."
   
   Meszaros goes onto to provide very valuable discussions of Goals of Test Automation, Philosophies of Test Automation, and a Roadmap to Test Automation. We talk about things like Tests as Specification, also known as Executable Specification: "If we are doing test-driven development or test-first development, the tests give us a way to capture what the SUT should be doing before we start implementing it. They give us a way to specify the behavior in various scenarios captured in a form that we can then execute (essentially an "executable specification".) To ensure we are "building the right software", we must ensure that our tests reflect how the SUT will actually be used." We also talk about Tests as Documentation.
   
   The main part of the book, of course, is the catalog of the patterns. Meszaros has provided a tremendous service to our community by not only cataloging and naming much of what we do, but also providing excellent discussions of why and how we do those things. I think, over time, this will be regarded as a seminal work in Software Development.



2. By now, the concept of "patterns" in program design is pretty well accepted. And the concept of test-driven development has a solid foundation also. But are there certain "patterns" to building and running those tests? The answer is yes, and the book that covers it is xUnit Test Patterns: Refactoring Test Code by Gerard Meszaros. If you use any of the xUnit software in your development efforts, you need to have this book...
   
   Contents:
   Part 1 - The Narratives: A Brief Tour; Test Smells; Goals of Test Automation; Philosophy of Test Automation; Principles of Test Automation; Test Automation Strategy; xUnit Basics; Transient Fixture Management; Persistent Fixture Management; Result Verification; Using Test Doubles; Organizing Our Tests; Testing with Databases; A Roadmap to Effective Test Automation
   Part 2 - The Test Smells: Code Smells; Behavior Smells; Project Smells
   Part 3 - The Patterns: Test Strategy Patterns; xUnit Basics Patterns; Fixture Setup Patterns; Result Verification Patterns; Fixture Teardown Patterns; Test Double Patterns; Test Organization Patterns; Database Patterns; Design-for-Testability Patterns; Value Patterns
   Part 4 - Appendixes: Test Refactorings; xUnit Terminology; xUnit Family Members; Tools; Goals and Principles; Smells, Aliases, and Causes; Patterns, Aliases, and Variations
   Glossary; References; Index
   
   Most of the books that cover xUnit software do so from the perspective of a technical manual. Everything is geared to writing the actual code for the test. Meszaros takes a different tack. He covers more of the "why" behind test writing in xUnit, as well as the basic patterns and principles you should be aware of when you're putting together your tests. People new to xUnit will throw together tests without much thought as to the structure and robustness of that script. Meszaros maintains that much of the same care that goes into writing and designing programs should also go into the test scripts. Patterns such as In-line Setup, Chained Tests, State Verification, and many others can adjust your whole mindset towards what makes a solid and maintainable test script that will serve you well both now and down the road when you have to make changes to the program (and add more scripts to your test suite). The book is set up such that you can scan for basic ideas, and then go back to specific patterns for more information as the situations and needs arise. With the use of both actual code and UML diagrams, it's very easy to catch the gist of each pattern, as well as seeing how it would actually be implemented. Very good stuff here...
   
   If you practice test-driven development (and you should), you have no doubt worked with your particular xUnit variant. This book is the next step in your learning, and it will make you a much better developer and tester...



3. Fine ideas in the area of managing the test code part of test driven development
   Aimed at developers, testers may find some ideas that fit in their ballpark too.



4. Let me start by stating the obvious: this is a patterns book about the organisation of tests and the workings of the xUnit family of unit testing frameworks. It is _not_ a book about Test Driven Development, although there is material that is pertinent to that. Given that the use of JUnit and TDD is pretty intertwined in the minds of many Java developers, it's worth making this distinction, so you know what sort of book you're getting. Speaking of JUnit, most of the code examples uses Java, although there are some examples in C#, VB and Ruby.
   
   Like Martin Fowler's Patterns of Enterprise Application Architecture, the book is split into two main sections, a narrative that weaves together a lot of the patterns and strategies, and then a catalogue of individual patterns. Between the two, there is a catalogue of 'test smells', similar to the 'code smells' discussed by Fowler in Refactoring, which I would suggest can be read profitably with the narrative section, rather than used as reference material.
   
   There are a lot of patterns here on the mechanics of xUnit, such as 'Test Runner', 'Garbage-Collected Teardown' and 'Named Test Suite'. I was a bit confused about who this material is aimed at -- maybe someone looking at porting xUnit to a new programming language would find it useful, but a lot of it is fairly obvious to anyone who's used an xUnit in a non-trivial fashion (and certainly, if you haven't done so, this book is not a format that makes for a good introduction), or requires playing against xUnit's strengths (e.g. not putting setup and teardown code in their eponymous methods), although there is good reason for doing so in some of the examples provided, such as databases.
   
   Beyond this, there is some good stuff on design-for-testability patterns (e.g. dependency injection versus dependency lookup), value patterns to replace magic constants, custom assertions and custom creation and other utility methods to make the intent of tests more clear. This material, along with the test smells chapter, is where the real value of the book lies. It encourages the application of the same software engineering principles you would apply to your applications (encapsulation, intent-revealing names, Don't Repeat Yourself) as you would to your testing code, something that's surprisingly easy to overlook, at least in my experience.
   
   Also, the material on 'Test Doubles' (mocks, stubs, dummies and their ilk) is extremely useful. It touches on designing with mocks only superficially, but it does provide a helpful taxonomy of what different classes of doubles do. Now, if only everyone would standardise on this nomenclature, it would make life a lot easier. I suggest we brandish this enormous book threateningly at anyone who refuses to toe the line, and that should do the trick.
   
   Because, boy, this book is big (about 900 pages). To be honest, it's too big. I rarely complain about getting too much book for my money, but the likes of GoF, PoEAA and PoSA 1 manage to come in between 400-500ish pages, so there's no reason XTP couldn't. The advantage is that the patterns in the catalogue, which take up most of the space, stand alone, without requiring too much flicking backwards and forwards between patterns.
   
   The disadvantage is that there is a lot of repetition, so unlike the three design patterns books I mentioned above, which I suspect most people read cover to cover (or maybe that was just me and I'm a complete freak), I would suggest only dipping into the catalogue as necessary. For instance, how much difference is there between the 'Testcase Class per Class', 'Testcase Class per Feature' and the 'Testcase Class per Fixture' patterns? Not a lot, as you might expect.
   
   I definitely liked this book. I would have liked it even more if it came in at about half its size and I would have preferred more emphasis on test and assertion organisation than the mechanics of the xUnit framework, but maybe that would have been a different type of book to the one Gerard Meszaros intended. This is nonetheless a must buy for anyone who cares about unit testing.



5. I've been familiar with agile concepts of automated unit testing (AUT) and test-driven development (TDD) for awhile now. In the past few years I've made several attempts at incorporating AUT and TDD into my own personal workflow, but each attempt soon resulted in my abandoning the whole idea. The testing effort quickly outweighed the benefits. I've believed in the ideal of TDD, but I didn't see quite how to pull it off.
   
   Then I bought XUnit Test Patterns by Gerard Meszaros. Wow! Finally the issues I've struggled with are being addressed. Okay, I must admit I'm not very plugged in to the online software development community, and I'm sure these issues have been discussed before. But this book looks special. I sense it's giving voice to these issues in a big way that's introducing many developers to these ideas for the first time. After all, it had to take time for this kind of book to be written. Time for the patterns to be developed through hard and frustrating work.
   
   Rarely have I bought a thick book on software development and eagerly read every single word from cover to cover. But I have with this book. And I know I'll soon do it again. I'm even tempted to also purchase the PDF version of the book, just so I can reference it wherever I happen to be.
   
   It's not the final word on AUT, but it has me embracing the ideal of TDD once more. The company I work for develops a huge OO-based enterprise software system with no automated tests. As Meszaros explains, this kind of legacy system is the most difficult for incorporating AUT (and daunting for those new to AUT). But at least now I feel like we have a good chance.

5 comments about Intermediate Perl.

1. I didn't like the storyline, but I did learn how to handle anonymous arrays better.



2. I picked up this book for a class that I was teaching at my office. The goal of the class was to train HTML/CSS/JavaScript and/or Java programmers to code in Perl since a large portion of our code base is written in Perl. Overall, I think that the book was a good choice for the class for a number of reasons.
   
   First of all, the book is already written with a classroom setting in mind. The authors have used previous versions of the book, titled "Learning Perl Objects, References and Modules", for their own courses. This updated version benefits from all of the hours of empirical testing that it has received in the classroom. There are many thoughtful additions like having all of the chapters close to the same size. This allowed for me to assign a single chapter per session and know that I could comfortably fit the lecture and discussion of the chapter into a two-hour session. There are also exercises at the end of each chapter and answers for those exercises (with discussion) in an appendix.
   
   This book is good for getting people just learning the language ready for the TMTOWTDI/TIMTOWTDI aspect of Perl. Take something simple like opening files... there are at least four 'standard' ways to do it. The book prepares you for all of the different versions of annoyances/features like this that show up in Perl code by walking through the evolution of the feature.
   
   Another reason that I like this selection of book is that data files and code examples are actually available for download. I've been shocked that some of the programming books that I've gotten lately actually don't have this addition.
   
   Finally, the course that I'm teaching is for people who probably already know how to program, at least a little, but they don't know Perl. I didn't want to drag them through all of the picky details of the language by starting with "Learning Perl" or something equivalent. This book has been a good choice for introducing programmers to Perl. I do have to stop occasionally and explain some fundamentals of the language, but not too often... maybe I just work with smart (or shy) people :)
   
   Of course, the book isn't perfect. As odd as it seems, one of the biggest complaints that I get is over the Gilligan references that are used in all of the examples in the book. There is also some coverage of packaging modules for CPAN. This is useful, just not for the particular class that I'm teaching, so we skipped that chapter. Of course, both of these complaints are pretty weak.
   
   In short, this is a good book, especially if you are doing a training session about Perl.



3. If you've mastered The Llama, make haste to read this one. Even if you only want to do scripting with Perl, you'll eventually find you need data structures slightly more complicated than just flat arrays and hashes, and you need to know about references for that. While The Camel does contain a fair chunk of material on just this subject, it was a bit too much for me to digest after The Llama. If Intermediate Perl (aka The Alpaca) had been around for me to read, I would have had a much easier time.
   
   Written in the same style as The Llama, this breeze through most of the rest of Perl, in particular: references, objects, packages and modules. These are the bits that you need to use Perl as a general purpose programming language, not just for scripting. In a similar pragmatic vein, it also covers how to use tools to build your own packages in the CPAN style, and there's a good chunk of material on using Test::More for unit tests. Probably the only thing missing is material on type globs and symbol tables, although hopefully, brian d foy's forthcoming Mastering Perl will fill in these gaps.
   
   The bottom line is this is Llama part 2, and you need to read it if you want to have any hope of understanding anyone else's Perl. But I can't give it five stars. The major problem is that the material is not very well organised. At the chapter level, objects are sandwiched between modules and packages. It would have been far preferable to keep the module and package information together. As a result, the distinction between modules and packages is rather muddied, and the introduction of objects in the middle just makes things worse. Overall, I found the explanations to lack the clarity of the Llama.
   
   A more minor complaint is that, while there are mercifully fewer annoying footnotes, the Gilligan's Island theme (if, like me, you had no exposure to this growing up, you might want to read the Wikipedia article first!) grates far sooner than the Flintstones flavour of the Llama.
   
   That said, make this your second book on Perl. Then, _still_ don't read The Camel yet. Avail yourself of Perl Best Practices first.



4. Successors are not always as expected. In this case you do get from this trio of authors, who are classics in their own right, just what you expect. In my own case, I needed to get good at OO Perl and fast. In three days, I covered the major chapters thoroughly, went off to my interview and in the end was told, "hey, you really know your stuff". This book intends and does indeed follow well the Learning Perl classic. If you finished the meat of the classic, this is the dessert. You'll recognize the writing style and flavour. There are no surprises. In my opinion, another classic.



5. This book has good perl examples and good perl code. It is a good choice if you have an intermediate understanding of the perl language.

5 comments about Sams Teach Yourself Adobe Dreamweaver CS3 in 24 Hours (Sams Teach Yourself).

1. Excellent book to learn about all the new features of Dreamweaver CS3. I had the MX 2004 version but just upgraded. The changes are phenomenal. Excellent book in a great line of Sam's books.



2. I found this book to be very helpful and informative. I'm new to Dreamweaver CS-3 and I found that this book really covers the basics of Dreamweaver and Web design and gets into some of the more advanced features. After reading this book I've really gotten a grasp of Dreamweaver. I find that it is especially a good resource in conjunction with the online seminars from Adobe.



3. The back of this book, which arrived today, says "User Level: Beginning" and they are right. Wish Amazon's description of the book would have said that. I can see why the book's style would appeal to beginners, but with much Front Page experience, I needed at least an intermediate text. Less on the basics (like relative vs. absolute paths)and much more on style sheets, tables, etc. Also missing (not even in the Index) was any mention of "Contribute" a new Adobe tool designed to be used by non-programmers to maintain Dreamweaver-built websites.
   
   So the book goes back and I will order something tougher.



4. I have read quite a few Dreamweaver books and this one by far is the easiest to follow. It has broken down steps in a way that gets straight to the point of what you need to do to build a site.



5. Sam's Teach yourself Adobe Dreamweaver CS3 in 24 hours, is a comprehensive book that covers virtually everything you will need to know about the program. I initially chose this book because I had limited experience with Dreamweaver and wanted to be able to learn the fundamentals very quickly. One quick note about the titles of these books. Sam's Teach Yourself in 24 hours series is a bit misleading in the sense that it doesn't actually mean you could pick up the book one night and be an expert the next. O.K. well sort of...The Sam's Teach Yourself in 24 hours series of books are composed of 24, one-hour lessons that cumulatively help the user to learn a particular software program.
   
   If you don't like learning theory or "why" something works then Sam's Teach Yourself Dreamweaver CS3 in 24 hours may not be the best kind of book for you. It is not the kind of book you can peruse on the weekend or take on a trip to help ramp up your skills. As an inexperienced Dreamweaver user, I found that I couldn't just go to the table of contents and select a section that sounded interesting. I felt like I had to start at the beginning and work my way through each chapter.
   
   I am a Dreamweaver novice but an intermediate user of html, xhtml, and css so the beginning of this book was not as useful for me as say someone with no experience at all. This book would probably best suit someone without any web development experience at all. A small knowledge is certainly not detrimental but it forced me to skim the beginning and I felt myself wanted to "do" something.
   
   This book doesn't have as many practice exercises as I would prefer. If you are someone who enjoys an included CD/DVD or at least a website with practice files then this book may not be the best for you. The book does suggest that you learn some fundamentals of web design/development by opening a pre-existing website. This task would certainly be helpful for the novice and is a good way to learn many CS3 features.
   
   As someone who has used these type of training manual books before I felt that the greatest assets that this book had several strengths including: 1) Comprehensive and Detailed Explanations, 2) A good amount of screen shots, 3) Content Is Well Organized.
   
   The weaknesses of this particular book include: 1) It is entirely black and white, 2) It is much too comprehensive for an intermediate user, 3) lacks an accompanying exercise files.
   
   I would recommend this book to someone with absolutely NO web design, web development, or Dreamweaver experience. I would also recommend they begin on page 1 and work their way through incrementally as the book is intended. Give yourself 24 Days and do a one hour lesson a day. That would be a great way to get through each of the lessons and thoroughly learn Dreamweaver CS3.
   
   Nate

No comments about Murach's ASP.NET 3.5 Web Programming with VB 2008.

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

1. This book is a fantastic starting point in life. Some how our public schools over look teaching the fundamental skills presented in this book. We learn how to play with toys on simple computers and never really learn what we are doing.
   
   The real strength of this book is in the definitions. We get to see the purpose and flexibility of system calls and functions. Not just use them but understand them. UNIX functions as job control or signals are explained in detail. Let's take just one item "waitpid":
   
   The waitpid function provides three features that aren't provided by the wait function.
   
   You will have to red the book to find out what they are. However there are examples also. Now for people with real systems like AIX all you have to do is ad a "k" to the front of the call and you have the AIX kernel function call "kwaitpid"; voila you now have an understanding that can not be found clearly in a Red Book.
   
   It does help some to have a preunderstanding of the system do you can use the book to fill in the education holes missed when necessary.
   
   The index is worth its weight in gold as you can find functions headers and concepts all in alphabetical order. My favorite is the definitions.
   
   As much as I am a fan of the internet it also pays to carry the information in the form of a book. And all this book has to do is save a couple of hours and it has paid for its self.
   
   Mastering UNIX Shell Scripting



2. This book is literally saving me right now in an Introduction to Operating Systems class I'm taking. We have projects to complete in the UNIX envrionment and the fact that this book gives you every real code example you could possibly need for all levels of systems programming is GOLD. It's laid out in a very straightforward way, has tons of code examples, and is overall awesome. Highly recommend if you're just getting into systems programming on your own, or as a school reference book.



3. This is one of the best books I've ever read about UNIX and programming.
   
   With its unique style, it serves as both a reference and a tutorial, and at the same time, it provides amazing detail and insight, always making the reader understand what's happening "under-the-hood". Fantastic job, Steven Rago and Richard Stevens!
   
   The only problem I had with this book was with the source code. It doesn't compile under MacOS X 10.5 Leopard, which is a certified Unix 03 system. It is a only a one-line change in the includes, so it's no big deal.



4. I occasionally need to fix broken IPC code and figure out behavior differences
   of legacy code between Solaris, Linux, etc., code written years ago by somebody
   else in C.
   
   This book, (and Stevens' earlier books before this) has been immensely useful.
   The code samples alone are worth their weight in gold :-). Seriously, this book
   has saved me many days of hard work, several times over.
   
   A quick browse of the book is usually enough to find the details (what I would
   call 'arcane details', but I guess this is because I'm not an expert C/networking
   programmer), figure out the problem AND how to fix the problem.
   
   This book has been a 'project-saver'. I cannot recommend this text too highly.



5. Its a very extensive book that covers concepts and advanced features of UNIX. It covers UNIX implementation of different features as a user point of view and how to access diffent services of UNIX like OSs. If you want to learn UNIX /Linux based programming this book a must read & must have for reference. I highly recommend this book

5 comments about Java(TM) Puzzlers: Traps, Pitfalls, and Corner Cases.

1. You really have to be a language weenie to care about many of these. If you're looking to become a better programmer, or simply to be entertained, this probably isn't the right book.



2. This book was so much fun to read but more importantly it surprised me a couple of times ... which is what i expected when i got it ...
   
   Cutting it short, if you are looking for some puzzlers ( some real ones ) get this book, at least you'll have some fun ...
   
   Regards
   Vyas, Anirudh



3. Completing the puzzles in this book will increase your knowledge of the Java language spec. This book was written by 2 of the world's foremost Java experts.



4. This book presents several problems that maybe even expert Java developers never thougt about. Some of them are only curious corner cases, others present tricky behaviours of the language that every developer must be aware of to avoid unwanted behaviours. I warmly suggest this book as a complement to "Effective Java", by the same author.



5. This is an amusing and at the same time amazing book that helps avoiding some very dark corners you might not have been aware of when programming in Java. I used FindBugs to test for some of the pitfalls described in the book in some codebases we had and did I find errors! Go get yourself a copy.

5 comments about Beginning Programming For Dummies (Beginning Programming for Dummies).

1. As a programmer, when I first read this book through I thought that it wasn't the best written of the Dummies books, but it was a reasonable introduction that gave a good overview of some of the basics. However, having seen people with no experience of programming at all try to work their way through this book, I've also noticed that the author has sometimes failed to really explain himself in the clear and thorough way that the Dummies books are so good at, and has lost sight of who the book should be aimed at - people with NO experience of programming at all.
   
   My biggest gripe of all is with the use of variable names, on two counts. Firstly, he'll sometimes use variable names that simply won't make any sense - names that have absolutely nothing to do with what the variable is actually being used for within the code. While this doesn't cause a problem with programming, and certainly won't confuse an experienced programmer within such simple coding, it can completely throw people who haven't used a programming language before - it adds unnecessary confusion to code that's mainly intended for complete beginners.
   
   It's also a bad introduction to naming conventions for anyone who'll write code for others to use, as people SHOULD try to make their choices of variable names make sense. It's a bad idea even if nobody else EVER reads it, because if you decide to come back to your code after a year, who knows if you'll still remember what "boing" was supposed to be?
   
   The second issue I have is that he'll repeat the confusion for newcomers by sometimes naming things too similarly. Experienced programmers, again, won't have a problem with this; but for the newcomers who're trying to become familiar with the language, it can confuse them - this is made more likely by the fact that many will already be struggling to come to terms with the code they're working through. Having a variable called test$ and a routine called [test] may seem fine to experienced programmers, but when test$ is actually the value of a radio button, there are much plainer and easier names that the variable could have been given to help avoid confusion for the novice programmer. It could simply have been thought through better, and more consideration should have been given with regard to who this book was intended for.
   
   When compared to some of the other Dummies texts, most of which people could work through from top to bottom without needing much or any assistance, this one falls short of the mark. Beyond just the confusion created by bad choices of names for variables and functions, some of the explanations are unclear - or leave some elements completely unexplained - leaving the unfamiliar programmer out of their depth, with no experience to call on to deduce what the commands or code may actually be doing.
   
   In the end, I simply wouldn't recommend this book to anyone who is trying to learn programming from scratch on their own. With some help, it provides a place for programmers to build, but too often the people I've seen work through this have ended up FEELING like Dummies as they became baffled and lost off by the book's sometimes careless style.



2. Well written, to the point, useful information made accessibe: a book that delivers what it promises. In spite of what one reviewer says above, the author goes out of his way to recommend that you use descriptive names for variables. My copy of the 2nd edition has this repeated on a "cheat sheet", printed on cardstock _just inside the cover_. At the top of page 2, under Tips for writing programs:" "-Use descriptive variable names". This book is a good introduction and overview to programming and I highly recommend Liberty Basic.



3. So I finally decided to try out the "For Dummies" books and must say it's a decent enough first step. I've always had an interest in learning some programming...mostly for fun but also because it seems that a basic understanding of computer programming is becoming more and more necessary...instead of taking a course I decided to learn a little on my own to see how it goes... The book is very easy to follow and explains things pretty well. I am definitely happy with the purchase and will continue studying programming. Would highly suggest for anybody with the desire to pick up a new hobby. Just purchased Robot Building for dummies...we'll see how that one goes.



4. A good overall explanation of programming in general. Becoming proficient in any of the languages taught, I think, will require additional reading. However, the basic concepts and building blocks of programming are well laid out for the reader. A great starter for someone with no experience in programming.



5. As a Computer Science student with NO PREVIOUS knowledge of any programming language, this book has been extremely useful to grasp the basic concepts of programming.
   Recommended purchase.

5 comments about Stop Staring: Facial Modeling and Animation Done Right.

1. I hate to say this, but didn't learn much more than which I had already been able to get from online tutorials and forums.



2. Have you ever worked with a facial rig that was based on a set of sliders in the viewport? Many of the most popular free rigs use that method these days. Well guess what -- it's sometimes called "the Osipa method," and it was popularized by the first edition of this book.
   
   As a novice character rigger, this book opened my eyes to an entirely new way of looking at facial modeling, rigging, and animation. I can not recommend it highly enough. These days when I create a character, I always have two books within quick reach: The Art of Rigging (by CG Toolkit, only available from their website) and Stop Staring.



3. Stop Staring: Facial Modeling and Animation Done RightThis book is a very good resource for computer animators.



4. I am a 3d professional artist for a long time, I have to say I have read hundreds of books, watched hours of training videos, read pages of internet tutorials anything related to 3d animation. No other training material comes even close to things I have learned reading this book. It is a treasure that you have to keep somewhere close to your desk as a reference, whether you are modeling a character head, building blend shapes or rigging . I have used the techniques successfully in many projects. I thank Jason Osipa for writing this book and for teaching me how to build superior 3D characters. This is my second SS book, I also have the first edition. This 2nd edition is a lot different then the first.



5. Hi, everyone.
   
   I bought this book. It's a huge disappointment for me. You beter buy the anzovin studio tutorial DVD's and look for a freeware JAVA applet called JLIPSYNC, use MIMIC or VOICE O MATIC This book makes it way to complicated.
   Basicly all you have to do is analyse your vocal track roughly not word by word or letter by letter. That doesn't work. Try to analyse your track phonetical and see where THE LIPS AND THE MOUTH CHANGES. LESS IS MORE IN LIPSYNC. Add eyebrow wrinkles and nose up or down movements. Look at the pose your character is in. SEE THE LIPSYNC TOGETHER WITH THE POSE YOUR CHARACTER IS IN. That will work.
   Reading this book won't.

5 comments about Microsoft® Office Outlook® 2003 Inside Out.

1. A most comprehensive treatment of Outlook. Extremely well suited for an experienced Outlook user, with many details on the use in a server/business environment. Describes the interrelationship with Windows Outlook Express. Probably a little too comprehensive for the single system user just trying to read and write a few email messages. Subject matter is exceptionally well presented and thorough.



2. Previous reviewer's comments are noted well, but I was somewhat disappointed in the coverage of forms development. I really wanted to learn to move/place fields on a contact form and designate them drop-down, etc. Simple enough, I thought, for a book of this coverage. But even though the author talked about the abilitiy to do this, there were no directions, no examples, and no description of the 'Controls' options required to do it. For a book of this size and price, I had hoped for more meat. No, not to the detail of VB scripting, but certainly more detailed coverage of Outlook's powerful forms and macro abilities. To my chagrin, I'm finding my answers under the Outlook 'Help' section in the program itself!



3. Too much said about the various steps. Not brief and to the point. Found it difficult to go step by step without reading, and reading, and reading.



4. Comprehensive and approachable. Good index and highly illustrated.



5. I found myself as the Outlook support for a new small business and I had only used Outlook for e-mail and contacts previously. This book has quickly become my total reference guide. It has helped me solve several problems. It's easy to read, well organized and very complete.
   I recommend it to anyone who needs to support an Outlook installation or an Exchange Server installation.

5 comments about OpenGL(R) SuperBible: Comprehensive Tutorial and Reference (4th Edition) (OpenGL).

1. I have no complaints! The most complete source of information for OpenGL you can find. I've spent a great amount of time searching through online tutorials, and nothing compares.



2. The information and code in this book are great. If that were my only criteria, I would rate it 5 stars. But I have ordered 2 copies so far in an attempt to get one with an acceptable binding. Both copies split at the color plate section the first time I opened them. The color plates are falling out. Amazon was nice enough to send me the second copy and have me ship back the first one free of charge. So I am giving up and am using the second copy even with the pages falling out (not much choice if I want the info in the book), but it is still irritating.



3. The binding broke the first time I opened it and half the color plates fell out.
   
   The code for the book is only provided in one huge zip file, and the compiled versions are outdated. They will crash on an updated version of XP if you are using a normal user account. The provided libraries for freeglut need to be recompiled to work on newer version of Visual Studio.
   
   No electronic version of the book is provided(unless you count having to sign up for "free" 3 month trial membership of some web service that allows you to view it for a limited time..bah).
   
   Sent an e-mail to the webmaster about providing smaller files for downloading the code, but there was no response.



4. This is an excellent book for OpenGL topic. I noticed it also includes the most recent works in the computer graphics field which makes it totally different from the free 1st edition bluebook on the internet. I read it everyday on the train to and back from the work. The words used in the book are easy to understand. The authors did a good job presenting the technical details. This is a must-have for all OpenGL software engineers. Would recommend to other people!



5. This book has three great uses: as a learning tool for beginners, as an update for intermediates, and as a reference for experts. All groups can be benefited from this book.
   
   With regards to the first, this book provides a much more natural progression between the topics when read front to back. Also, it does not assume a lot of mathematical knowledge, and it will provide some of it as it goes along.
   
   Also, for people who know OpenGL 1.x, this book will be a great way of being introduced to shader programming as part of OpenGL. Also, something I found invaluable in this book is the chapters in optimization (buffer objects, etc). It talks enough about optimizing OpenGL to high-performance applications without delving into 3D engine design (something that is out of the cope), but still filling a niche. Last, it talks about several things that are taken for granted by professionals but novices sometimes have a hard time accessing (post-processing, multiple passes, image processing, etc.)
   
   Even professionals will find the book useful for looking things up, or to use as a reference.