5 comments about OpenGL(R) Shading Language (2nd Edition) (OpenGL).

1. The OpenGL Shading Language is without doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. As one of the primary contributors to the development of the language, Rost provides a clear and well-written explanation of the language and how to use it.
   
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders.
   
   The book ends with a handy comparison of GLSL with other shading languages, such as Cg and HLSL, and a couple of appendices providing a language grammar and API reference.
   
   If you're doing shader development with OpenGL, you'll definitely want this book on your desk. My only complaint about it is that it was written before GLSL was officially promoted to the core. When that happened, a number of important things were changed that aren't reflected in the book. However, determining the differences isn't difficult, so don't let that deter you from picking this up.



2. Twenty years ago, I used to program graphics on an Evans and Sutherland PS340. It was then one of the top of the line graphics computers (costing $100k). It could labouriously do shading, but only Phong and Gouraud. Nowadays, many PCs have this ability, and much faster. But a problem still persists, where often the shading methods are restricted to what is implemented on the graphics chips.
   
   In contrast, you have the approach in this definitive book on OpenGL Shading Language. This lets you implement in your code, shading routines of your own devising. To be sure, given the same shading method, one done in this language, and one in the hardware, then the latter will have better performance. But it turns out that today's computers are fast enough, and have enough RAM, that the difference in response might not be appreciable.
   
   The book describes an extensive set of built-in convenience functions that come with the language. And the language's API is explained in detail. The author rightly recommends that you come at it with some experience in the standard OpenGL.
   
   Since the language is still quite new, you are more or less on your own, when looking at development tools. This dearth is expected to be remedied in a few years. But right now, you'll have to rely on your wits. Along with a chapter that gives general principles of how you should develop your own shader. What may be even more use, however, is the second half of the book. Devoted to case studies of many shaders. Understanding these may be more beneficial than any IDE.
   
   Oh, as you might expect from a graphics book, there is a lovely set of colour plates in the middle of the book, showing what custom shaders can do. Treat it as inspiration if you wish.



3. The recent trend in graphics hardware has been to replace fixed functionality with programmability in areas that have grown exceedingly complex (e.g., vertex processing and fragment processing). The OpenGL Shading Language has been designed to allow application programmers to express the processing that occurs at those programmable points of the OpenGL pipeline. Independently compilable units that are written in this language are called shaders. A program is a set of shaders that are compiled and linked together. The OpenGL Shading Language is based on ANSI C and many of the features have been retained except when they conflict with performance or ease of implementation. This shading language is without a doubt the most important addition to OpenGL since its inception, and this book provides an excellent guide to programming with it. The author was one of the primary contributors to the development of the language, and he provides a well-written and insightful explanation of the language and its use.
   The book begins with a review of OpenGL basics, followed by an introduction to shaders and how they fit into the pipeline. It then covers the language itself, including data types, operators, interaction with the OpenGL state machine and fixed function pipeline, built-in functions, and more. It also introduces and explains the OpenGL APIs needed to use shaders.
   The last half of the book focuses on shader development, including general process and workflow, and coverage of many specific techniques, such as procedural textures and GPU-based animation. It even includes a section on implementing the fixed function pipeline using shaders. The book ends with a handy comparison of OpenGL Shading Language with other shading languages, such as Cg, HLSL, and Renderman and a couple of appendices providing a language grammar and API reference.
   I particularly liked chapters 6 through 8, which take you from a simple shading example -"brick"- through the specific steps of shader development that you would need to master regardless of the API you are using. Also the chapters on procedural textures and noise and the accompanying code examples helped clear up some matters that were murky when I read "Texturing & Modeling: A Procedural Approach" by Ebert et al. In summary, I highly recommend this book to anyone interested in implementing software shading, both from the standpoint of OpenGL and from the standpoint of the design process itself. I notice that Amazon does not show the table of contents for the second edition, so I do that here:
   Chapter 1. REVIEW OF OPENGL BASICS
   OpenGL History; OpenGL Evolution; Execution Mode; The Frame Buffer; State; Processing Pipeline; Drawing Geometry; Drawing Images; Coordinate Transforms; Texturing;
   
   Chapter 2. BASICS
   Introduction to the OpenGL Shading Language; Why Write Shaders?; OpenGL Programmable Processors; Language Overview; System Overview; Key Benefits;
   
   Chapter 3. LANGUAGE DEFINITION
   Example Shader Pair; Data Types; Initializers and Constructors; Type Conversions; Qualifiers and Interface to a Shader; Flow Control; Operations; Preprocessor; Preprocessor Expressions; Error Handling;
   
   Chapter 4. THE OPENGL PROGRAMMABLE PIPELINE
   The Vertex Processor; The Fragment Processor; Built-in Uniform Variables; Built-in Constants; Interaction with OpenGL Fixed Functionality;
   
   Chapter 5. BUILT-IN FUNCTIONS
   Angle and Trigonometry Functions; Exponential Functions; Common Functions; Geometric Functions; Matrix Functions; Vector Relational Functions; Texture Access Functions; Fragment Processing Functions; Noise Functions;
   
   Chapter 6. SIMPLE SHADING EXAMPLE
   Brick Shader Overview; Vertex Shader; Fragment Shader; Observations;
   
   Chapter 7 OPENGL SHADING LANGUAGE API
   Obtaining Version Information; Creating Shader Objects; Compiling Shader Objects; Linking and Using Shaders; Cleaning Up; Query Functions; Specifying Vertex Attributes; Specifying Uniform Variables; Samplers; Multiple Render Targets; Development Aids; Implementation-Dependent API Values; Application Code for Brick Shaders;
   
   Chapter 8. SHADER DEVELOPMENT
   General Principles; Performance Considerations; Shader Debugging; Shader Development Tools; Scene Graphs;
   
   Chapter 9. EMULATING OPENGL FIXED FUNCTIONALITY
   Transformation; Light Sources; Material Properties and Lighting; Two-Sided Lighting; No Lighting; Fog; Texture Coordinate Generation; User Clipping; Texture Application;
   
   Chapter 10. STORED TEXTURE SHADERS
   Access to Texture Maps from a Shader; Simple Texturing Example; Multitexturing Example; Cube Mapping Example; Another Environment Mapping Example; Glyph Bombing;
   
   Chapter 11. PROCEDURAL TEXTURE SHADERS
   Regular Patterns; Toy Ball; Lattice; Bump Mapping;
   
   Chapter 12. LIGHTING
   Hemisphere Lighting; Image-Based Lighting; Lighting with Spherical Harmonics; The *erLight Shader;
   
   Chapter 13. SHADOWS
   Ambient Occlusion; Shadow Maps; Deferred Shading for Volume Shadows;
   
   Chapter 14. SURFACE CHARACTERISTICS
   Refraction; Diffraction; BRDF Models; Polynomial Texture Mapping with BRDF Data;
   
   Chapter 15. NOISE
   Noise Defined; Noise Textures; Trade-offs; A Simple Noise Shader; Turbulence; Granite; Wood;
   
   Chapter 16. ANIMATION
   On/Off; Threshold; Translation; Morphing; Other Blending Effects; Vertex Noise; Particle Systems; Wobble;
   
   Chapter 17. ANTIALIASING PROCEDURAL TEXTURES
   Sources of Aliasing; Avoiding Aliasing; Increasing Resolution; Antialiased Stripe Example; Frequency Clamping;
   
   Chapter 18. NON-PHOTOREALISTIC SHADERS
   Hatching Example; Technical Illustration Example; Mandelbrot Example;
   
   Chapter 19. SHADERS FOR IMAGING
   Geometric Image Transforms; Mathematical Mappings; Lookup Table Operations; Color Space Conversions; Image Interpolation and Extrapolation; Blend Modes;
   
   Chapter 20. REALWORLDZ
   Features; RealWorldz Internals; Implementation; Atmospheric Effects; Ocean; Clouds;
   
   Chapter 21. LANGUAGE COMPARISON
   Chronology of Shading Languages; RenderMan; OpenGL Shader (ISL); HLSL; Cg;
   Appendix A. Language Grammar
   Appendix B. API Function Reference



4. I'm not a fan of the 'group of papers' style of book. But this book pulls it off nicely. The text is consistenly good throughout. And the illustrations and formulas are high quality and presented nicely.
   
   I would have liked full color throughout, but I accept that it would have been cost prohibitive on a book of this heft. Speaking of heft, yeah, this is a doorstop of a book. I think some of the text could have been edited down and the formatting tightened up to reduce bulk.



5. I definitely recommend this book for anyone working with OpenGL's new Shading Language. I would, however, say that probably the most difficult part of working with GLSL is getting it working in the first place. Especially on Linux, this is somewhat confusing - some cards support GL 2.0, some don't, but still support the GLSL if using the ARB function calls. I would also make sure to point out to new users that GLEW is close to essential when working with the GLSL - you can download it from sourceforge. It might be worth mentioning in future versions of the book, along with ARB functions which are the same as the GLSL standard functions shown in the book.

5 comments about Foundation ActionScript Animation: Making Things Move! (Foundation).

1. I bought this book along w/ about 4 others that I needed. This one was the splurge... I was simply going to browse through it and see what I could pick up from it - not really thinking I could fully grasp the advanced concepts.
   
   To my suprise, this book brought you all the way back to those good ole Trig classes and explained what you'd need to recall (or re-learn) and why. Every concept was very well explained and one concept builds upon the next.
   
   It's definitely no light read, but if you really do have a desire to learn, this is the book.



2. I will atest that this is a great book IF you are an actionscript junkie, but if your not you will hate this book. I was looking for a book to help my students with thier Flash animations and this book was way beyond where I wanted to take my students.



3. I was tasked with producing eight Flash simulations for an engineering dynamics course this past summer. I programmed the simulations using ActionScript with algebra and calculus introduced to control the behavior of a variety of objects -- no small task if you consider that I am an English teacher and not a programmer or engineer.
   
   By doing and redoing the problems posed by Peters, I could eventually understand them well enough to be able to program similar modules for my project. No idea seems too difficult for him to explain in a manner a beginner can understand, particularly with the working models at the FriendsofED.
   
   I purchased nine books on the subject at the beginning of the project. I ended up using this one more than all of the others combined.
   
   I also recommend his ActionScript 3.0. Being the same book written for two different versions of ActionScript, the two books give us a really good opportunity to compare and contrast the two languages.



4. Foundation ActionScript Animation: Making Things Move! is a surprisingly well-written book. I started with Flash 3, moved to server-side languages with Flash MX, and now, years later getting back into Flash has been a journey to say the least. This book, more than the five or six others I have purchased, has made the transition fairly easy.
   The author has done an excellent job in breaking down Flash math for those of us old school, tellTarget, gotoAndPlay, motion tween people. The best part of this book... the examples are error free. Which should go without saying, but in this day and age it is surprising how many tech books out there (their authors in a rush to publish) have irrelevant or incorrect example code. Highly recommended.



5. I'm only on chapter 5, but this book really lays out all of the tools you need to prototype and/or develop video games in Flash. At first I was a little upset because the author seemed to skip over some elements for the beginner, or rather the rusty flash programmer, but he explains just enough so that if you want to dig into it you can. This book probably isn't for the very beginner. You need to have had some Flash experience and/or some Flash programming experience to really get everything, but a couple of tutorials should be enough. Highly recommended.

3 comments about InDesign CS2 For Dummies (For Dummies (Computer/Tech)).

1. This book sits next to me all day. I read it front to back and am now using it as a reference during my projects. This book is worth it if you have or plan to purchase CS2.



2. While this book has helped me to get up and running in Adobe InDesign, I am not overwhelmed by it as a resource. For one thing, it needs more screen pictures and clearer screen pictures. I also found several instances where knowlege was assumed - the editors has skipped to the conclusion of a task, without really explaining it. I guess that they assume most layout designers will know how, but for those more familiar with Microsoft products, that is not the case. Finally, the index at the back of the book is sorely lacking. I could not find many basic elements of the program listed there, so the index is not always much of a resource for jumping right to the area you need.



3. I started a new job in January and wasn't told that part of it would involve working with InDesign. Knowing nothing about that program, I immediately ordered my trusty "Dummies series" book - it's taught me everything from raising a Golden Retriever to Tarot Cards! Needless to say, the InDesign book didn't fail me. All the basics were there. The only problem was that sometimes I didn't know what to look up in the index because I wasn't sure what the process was called. Other than that, it was and continues to be a great resource!

1 comments about The Essential Guide to Open Source Flash Development (The Essential Guide).

1. I saw one copy of this at Powell's Technical Books in Portland yesterday, and picked it up, figuring it was new. It was--just published in the last few weeks. I haven't delved into it as much I would like, but that doesn't matter here because I carefully reviewed the contents before purchase.
   
   So: why buy this book? If you're working with Flash and ActionScript 3.0 currently, you know the Flash world is a moving target that changes very rapidly, and the main reason for this is the addition of open-source tools and "classes." This book gives us a needed status-check on what's currently available, how to get it and how to use it.
   
   In my case, I was mostly interested in Papervision3D, the Google add-on that has rapidly gone from cute curiosity to must-have in every Flash developer's bag of tricks. However, you don't really need this book for Papervision3D--there's plenty of documentation available online.
   
   Likewise, if all you really want to know is how to implement SWFObject (a popular add-in that lets you update a Flash element by updating your html or external text file), or how to make Flex work with XML, you may not need or want this book.
   
   But if you like to read about some fun new stuff that's available and that you might like to explore--all of kinds of mashups, FUSE, HAXE, Red5 video--then grab this book right away. It's readable, fresh, and informative--like most Friends of ED books. Also like most other Friends of ED books, it will rapidly go out of date as the moving target moves on!

1 comments about Mathematica by Example, Fourth Edition.

1. If you learn by example rather than by formalism, get this book. This presents the material in a logical framework with LOTS OF EXAMPLES. A companion volume is "The Mathematica Handbook", also by the same two writers. I used these books extensively in grad school. I remember standing in the university bookstore for 30 min comparing the handful of books available on Mathematica and these two books won out then and now still cover the fundamentals well. I still use them in my work today.

   NOTE: The volume I have only covers up to Ver 2.2, but I noticed the latest has 1997 copyright, so might now cover later versions.

5 comments about Inside Solidworks.

1. This is the best of the Solidworks books I have used. My only major complaint with the book is that it will not sit flat on the desk while I am using it! A minor issue is that future lessons often depend on files created in earlier lessons. Be sure to save your earlier work!



2. Overall coverage of this book is better than most (SolidWorks for Dummies and Sham Tickoo's books). Coverage includes Sheetmetal, surfacing and SW 2006 material. Only negative, the book has few example problems. If your looking for a lot of example problems, I would recomment the Sham Tickoo books.



3. As a SolidWorks user with over 8,000 hours experience and a Sr. Mechanical/Structural designer this book helps you through some of the hurdels you encounter. As a designer I want to spend my time designing not trying to figure out the software and do what I want it to do. Solidworks is easy to use but sometimes you need some reference material to describe a particular problem. This book does just that. It has a good overall approach to almost every problem. It is not at a fine detail level because there is too much material to cover but I would highly recommend this book for anyone that needs help problem solving the software intent. I had puchased earlier versions of this book and this latest printing did not disappoint me.



4. I've used CAD programs for about 17 years starting with Autocad, and this is by far the best software book I've used. It's readable, concise, well organized, and user friendly. The author is very familiar with the program and shares his opinions in a useful manner. I'm hoping that Mr. Murray has a new revision to keep up with the SolidWorks releases.



5. This book help you think and has good excercise to improve your solidworks skills. It a good book to used when taking a class. I would not recommend to use if you never used solidworks before and are not in a class

5 comments about The Photoshop Channels Book.

1. Scott Kelby uses an easy style to get the information he wants to present across to the reader. It may not be for everyone but it made the material more accessible for me. I was able to quickly absorb a lot of information. I read the entire book first and now I am going back and doing the excersizes. I have been using Photoshop for several years but I have not used channels until now. Recommended.



2. Scott's style of writing in this book becomes a little overbearing at times, as he tries to be amusing at every turn of the page. That makes it rather hard to read the book a second time to review things one may have forgotten.
   
   Having said that, Scott doesn't write as if the reader is an imbecile, and the pace of the book is good. Scott clearly explains each step required to use channels and if you follow along you are amazed at the end of an exercise how much you have accomplished in a short space of time.
   
   Because of the large number of screen shots, the book can be easily read without sitting in front of the computer, which is handy if you want to read it on the plane or over a beer at the pub.
   
   I therefore recommend the book for people with a variety of skills in the use of Photoshop. That ranges from anyone who knows what a layer is through to an advanced user.



3. Excellent: Easy to understand, detailed, great for beginner's to the advanced. I learn something new every time I open this book.



4. Like most of Kelby books very usefull guide and very easy to understand. Even if you only know a little of english like me. Recomended



5. I like the way Scott designs his information, it makes it easier to absorb, and skim through if I already am familiar with it. Full of to-the-point tutorials, I learned a lot from this book. Also, he freely plugs other authors who give more in-depth teaching, which I appreciate since his books are not ultimate "Bible" type works. His goofy humor is featured in the intro to each chapter, barely worth a chuckle most of the time, but at least he's not an unbearable ego maniac schooling the unwashed masses like Dan Margulis. Recommended.

5 comments about Filthy Rich Clients: Developing Animated and Graphical Effects for Desktop Java Applications (Java Series).

1. This book is fantastic - so many tips and tricks that I was unaware of. I want more!! I hope a sequel is in the making!! Check it out!! You won't be disappointed!!



2. I want client-side java very much to succeed, especially now that it is open source, but the java.com site itself uses flash instead of applets, and the first author of this book no longer even works for Sun on java stuff - he now works on Adobe Flex:
   http://graphics-geek.blogspot.com/2008/02/what-hello-world.html



3. To push java's ui capabilities has in the past been a bit of a struggle due to the many ways of dealing with Swing, repaints, events, animation etc. This book is an absolute life saver in terms of presenting a unified best practice strategy for everything a ui developer would wish to do in java. It creates very simple applications with solid explanations of what the code is doing, from the low level to the high level. It is also written in a very personable style and the book moves easily and logically through the related material. I wish I had read this book 4 years ago.



4. I have also enjoyed this book very much. Many of these techniques, such as using of intermediate images, were known to me, but numerous details escaped my attention. For example, using of 'compatible images.' I had no idea that this notion exists. I also enjoyed the timing experiments with wait and disclosure of its granularity. Their description of Animators is probably the best and most comprehensive of everything what I saw so far, its a real value-add for me.
   
   I will not repeat the positive accolade summarized here by others, I have one very substantial objection, which is really well summarized in the title used by someone else's comment:
   
   "Practice what you preach."
   
   The book preaches performance, efficiency and style, and yet the authors implement some enormous convoluted scheme around their own code sniplets!
   
   Of course, interested in all the timings and performance of the examples, I wanted to run and watch them. And... I failed at first. I have spend, or wasted rather if you so want, a lot of time in an attempt to achieve this goal.
   
   This sounds so easy nowadays to provide Webstart Java, or merely to deliver some *.java or *.class files, separate or in a *.jar archive.
   
   Not so for Chet and Romain: Their own web page claims that you can download a plugin for Net-Beans and run the examples. Net Beans has proven to be a product, a specific development environment, with which you may or may not be familiar. I never used it and I cannot operate it. Nor am I interested in learning it, being perfectly happy with my own Java setup. But be it as it may, I installed it in the hope to run these demos. It flooded my disk with some 125Mbytes and thousands of files, the usual mayhem, but we have now Terabytes at home, don't we? I also downloaded the plugin, and started to click around to get anything running. Lost in unfamiliar windows and menus I found nothing, no way to start any demo.
   
   I must be getting old. My rusty PhD Dr.Evil brain is too stubborn to crack usage of NetBeans, I failed the IQ test. All right than, I give up. Lets download the source code, run javac and be happy. What can be so difficult, wouldn't you think Minime?
   
   Nope! The adventure has just begun!!
   
   Click on Chapter 2, Swing Rendering Fundamentals. You will get an archive frc-chapter2.zip, in which root directory is no Java code at all. I see merely two folders and two empty files with the same name. On a hunch, step down into the directory SwingRenderingFundamentals, only to find another set of folders and a set of empty files, each with the same name like one of the directories. On a hunch lets step down into HighlightedButton, where we find a bunch of alien looking files and 3 more directories, with you guessed it, 3 more empty files carrying the names of these directories.
   
   Among them is build.xml. XML eh? Hmm... what do I do with that? None of my systems can do anything with XML, this book is not about XML, I do not need to use XML, do I? It's a practitioners book about a specific aspect of Java. I would be happy to stay with "javac" and "java" only, please.
   
   On several places I see a directory called CVS, this may or may not be a name of some source code managing tool. For example, a CVS directory (accompanied again by an empty file with the same name) contains 3 files. Each seem to have some generated content, like this file called Entries: /HighlightedButton.java/1.1/Tue May 01 22:48:46 2007/-ko/
   Hm... It most probably serves a project tool of a sort. But how this relate to the book and to the task at hand?
   
   But one directory name is "src". Source, hurray, the treasury hunt might be close to an end! Indeed, this is how you can 'fish' for Java files, best done with a script of a sort to copy all java files into one single place. You will be fine, most of them do not has any package specification corresponding to the directory they were found in. Once you get these files filtered out, you will even find among them Java files containing mere 2-3 lines of code, accompanied by the monster 30-lines Sun copyright node. Vive la lawyers!
   
   Equally convoluted is the way to access these files on Java.net. In a hope for an easy one-click demo, boy I am a lazy spoiled individual, and not willing to give up just yet, I registered an account with Java.net and dived into filthyrichclients.dev.java.net, only to find the same convoluted way of keeping here and there a Java file among a forest of directories and sidecar files. Here however, I got finally educated that CVS is a repository system, and the web pages provide some comprehensive help in its use.
   
   Please do not take me wrong: I do not want dismiss usability of any tool, like NetBeans or CVS, but pardon me, I was happy with my setup. "If it isn't broken, do not fix it," I do not need to get hundreds of megabytes of some unrelated software in order to find a few demo lines of Java, do I?
   
   Authors of a book teaching practitioners in minimality of algorithmic and best application of a graphical API, claiming to provide code examples of merit, should be focussed strictly on the implementation of just such philosophy, and not on their tools. A use of a language like Java can be explained and demo'ed using strictly the Java compiler and its own Java Virtual Machine. Compare this convoluted delivery with other Sun Java tutorials and their one-click demos. I hope that the authors would use "find" of their vast repositories of files to make a tiny set of *.java files, maybe even of class files. That would be all what a reader would need.



5. This book will save you hours of trouble shooting the little things that don't work as intuitively as they should in Java.
   I have not found an un-useful idea here.
   It also shows you how to make your application more efficient (faster).
   The author has already done the timing tests and offer you the results and the routes you should take.
   All in all, a fantastic find.

5 comments about Foundation Flash Cartoon Animation (Foundation).

1. There are many books about cartoon animation in Flash. What sets this book apart from the rest is the approach the authors have taken to make this book much more than just another step-by-step book about drawing and animating characters. Foundation Flash Cartoon Animation is for the animator who needs to stretch beyond the mechanics of the Flash tools and perfect the decision-making process necessary to become a productive animator. One of the biggest questions that is answered in this book is when to use Flash and how to use it most efficiently. The next question is what tasks are beyond Flash's capabilities and when to turn to another software such as After Effects.
   
   The authors assume that the reader has a basic knowledge of Flash and the principles of animation. Because of this, you will find only a few step-by-step examples. What they do cover thoroughly is every phase of the production process for cartoon animation from planning, storyboards and animatics to post-production and delivery. The approach for this book is to examine working examples which can be downloaded from the publisher's website.
   
   If you have ever created a complex character animation including lip synching and facial expressions, then you know that your character must be divided into a large number of individual animated parts. This is why the authors dedicate a whole chapter to organization and using the Flash library system to build character libraries. As you progress through the process from head comps and onward, the authors show when it is best to draw from scratch and when to use Flash symbols. Storyboards and animatics are next in the production process and the book covers several decisions that must be made such as choosing between traditional, hand-drawn storyboards and the digital method in Flash.
   
   Moving from the planning stages to character creation, the authors discuss the technical and organizational issues such as Flash file structures and project architecture. They take a look at several working examples to give the reader a comprehensive overview of this topic. One of the most helpful aspects of this book is how the authors help you decide when Flash is not enough to get the job done and how to expand Flash's capabilities with plug-ins. They discuss several of their favorites, how to find more on the web and when to make your own.
   
   One of the most important decisions that an animator will need to make is the choice between traditional frame by frame animation and tweening. The authors share their four step process for frame by frame animation and then discuss tweening and how to avoid common mistakes.
   
   I mentioned earlier that the authors discuss the use of a dedicated motion graphic software such as After Effects to take your Flash project to a higher level of quality and sophistication. They discuss some of the advantages to using After Effects for editing and composition such as complex camera movements and 3D effects.
   
   Flash has been plagued by one major drawback since its conception a decade ago and that is the extreme "digital" look of the vector artwork created in Flash. The authors share several tips and suggestions for enhancing your Flash project to achieve a more "hand-drawn" appearance to your animation including line styles and color choices. They also cover the digital equivalents for traditionally hand-drawn special effects such as distortion, drag, fade in/out and blurs.
   
   This book was a joint effort of several authors. Tim Jones is an Emmy Award-winning producer and writer and head of production at ANIMAX Entertainment. Barry J. Kelly is an Emmy Award-winning editor and artist and is also a member of ANIMAX Entertainment. Allan S. Rosson is animation director at ANIMAX Entertainment and has over twenty years experience as an animator. David Wolfe was an animator at ANIMAX Entertainment and is now with Cartoon Network Studios.



2. This book is a must for everyone who is tired of animating on paper and wishes to digitalize their work completely in Flash or After Effects. The book covers many great aspects including; making shortcuts of your workflow with user made extensions, brilliant tips & tricks and personal advices how to make life easier for the animators.
   
   This book is also amazing for those who already have knowledge of Flash or After Effects, but wish to enhance their skills or take their production to the next level.
   
   After reading this book, my animation workflow and quality improved.
   
   Best recommendations from here.
   
   
   -Alex Volkov (Flash Animator)



3. If you're looking for a book that teaches you how to draw in Flash, this is not the book for you. It will, however, teach you the nuts and bolts of animation, the technical information necessary to make animation less time consuming, which is a must-have imo.



4. I found very helpful the guides given by the authors. I was trying to figure out how develop a short cartoon animation in a correct way and after I read this book I found the answers. Thanks!



5. I've been a professional animator for over 10 years and I found this to be a valuable resource. It's written by some very talented people over at Animax Entertainment, who have tons of production experience. It offers great organizational tips and tricks for building and animating your characters. It also gives so much insight from the perspective of working on a larger productive team. Sure it's easy to develop your own ways of working when you work by yourself, but the suggestions in this book are a very smart and efficient approach for working on any sized project. They also give you a list of plugins that will help... and even describe how to make them work for you. And the information on how to make use of After Effects is just fantastic. I've adopted so many time-saving ways to work... things I never knew about in all of my years using Flash! I am using this book constantly for reference as I work on my new cartoon project. Thanks guys!

5 comments about Pattern-Oriented Software Architecture Volume 1: A System of Patterns.

1. This is an unusual book in the pattern genre. It presents a number of patterns, categorized by archtiectural level. That's just the first part of the book, though. The third of the book is about the process of using, relating, collecting, and distributing patterns.

   Only chapter 2 really addresses patterns for the strategic, architectural level of a software system. It does a very adequate job, using a variety of notations, examples, and analysis steps. This book is from 1996, so time has changed our view of some patterns. "Reflection," for example, has become pervasive in applications based on plugins and software components. It is also a fundamental API in the major langauges (Java and C#) released since this book was published - perhaps reflection should be downgraded to an "idiom". That's just nitpicking, though, since reflection is even more important now than when the book was written.

   For contrast, the authors present additional design patterns (including some from Gamma's book) for use at tactical design levels. They also discuss idioms patterns that typically involve just a few lines of code within on function. The contrast between the three different levels of implementation and design gives a useful discussion. The authors also present a weak chapter on "systems" or "langauges" of patterns The discussion is OK as far as it goes. The weakness is in what it omits. After reading this brief chapter, the programmer has very little practical information about choosing patterns from some library for some task. The poor programmer has no information at all about how to link patterns together, and that's a real stumbling block for beginning pattern users.

   The final section of the book is really sociology. It's about the pattern community, what that community is for, and how to be a working member. I find the discussion un-helpful, but I expect opinions to differ.

   Even today, this is a good second book (after Gamma's 'Design Patterns') on patterns and pattern usage. It lack the depth and precision of Gamma's book, and tends to add words without adding meaning. On the positive side, it's broader than Gamma's, and addresses a wider range of implementation levels.




2. First of all, you need to understand the patterns in the gang of four book before you attempt to read this one. They talk about them all over the place without explaining them. That's a warning, it didn't affect my review.
   
   The major thing I don't like about this book is the abstractness with which they talk. They give you a high level description of a pattern and leave you with that fogginess.
   
   I think the examples were poorly chosen. I would have prefered to have examples that are only as complicated as they needed to be. Unfortunately the book uses examples like, "We're going to make a voice recognition application" or "We're going to make an OS that can run applications that were built on Unix or WinNT or Linux". I think the intent was to have some real-world-I've-been-working-for-six-years examples... it would have been smarter to put the real world examples in a separate chapter and keep the design pattern explanations simple.
   
   Also, I hate the diagrams. They should have just copied the diagrams in the GoF book! Instead they chose these diagrams that give less info and IMO are downright ambiguous in some situations. Another thing the GoF book does is have 2 separate diagrams, one that's a (simple) real world example and another that's a diagram of the actual pattern. This book only has the diagram of the actual pattern.
   
   I disagree with those that say this book is better than the GoF book. I think what they like is the material covered. Material aside, the GoF book presents the information in a much clearer way. That's why I prefer the GoF book over this one.



3. Second best isn't bad when the #1 book changed forever the way software architecture is talked about. GoF is not only well-written, but it covers all the basic, most-used patterns. Everybody thereafter is going to have to either re-hash GoF, criticize it, or come up with new patterns which are not as fundamental.
   
   This book is full of new patterns, and fortunately they are good ones: Command, Broker, Layers and worth the price of the book in itself Presentation-Abstraction-Controller.
   
   PAC can be seen as a generalization and extension of Model/View/Controller. The Abstraction is the domain-specific part of the architecture, effectively the Model. The Presentation exposes the Model in some interesting way, either as a user-interface in which case it is a View, or as an API, in which case the Presentation becomes a new Abstraction used by the next level up. The Controller is left with the job of coordinating the Presentation and the Model. The key to the pattern is that PAC agents can be built up into layers with the Presentation API of each lower agent creating a higher abstraction for the next level. Thus PAC becomes MVC for all or your architecture, not just the UI.
   
   The book goes into this at length and adds useful discussion of MVC. Highly recommended.



4. A lot of the reviewers have said that this is the #2 best book about patterns : just trust them. I have bought it with the hope to learn more about patterns, finally it has given me a larger point of view about the subject and has improved a lot my creativity during software designing processes.
   
   If your new to patterns just read the GoF, then buy this one. I think you will then have a nice knowledge about the subject.



5. This book uses an easy way to explain system patterns. I think every software developer has to read this book; it's a nice reference to help software architects doing a well-done job. Another great reference that you may have in your list of references is the classical book "Design Pattern", also at Amazon.com.