From a Flex developer’s perspective, ActionScript 3.0 Cookbook, by Joey Lott, Darron Schall, and Keith Peters is pretty hard-core Actionscript (I know it’s ActionScript… Actionscript is easier to type).  Many of the graphical recipes use the Sprite class, and there are plenty of references elsewhere to classes that have simpler to use, more watered down counterparts in Flex.  At the risk of not being techinically correct, you could almost say it’s an “advanced” Flex cookbook.

This book has given me a deeper exposure to Actionscript, a deeper exposure that I find myself in need of more and more as I try to bend Flex to do my will.  I’ll admit, I avoid the Sprite class and the Graphics class unless I’m in a situation where it’s unavoidable and I absolutely have to use them.  Setting that aside, there are some things I routinely find too abstracted in Flex that I need to get at with base Actionscript.  The TextField is a perfect example of this, a powerful component that is somewhat diluted for use in Flex.  The authors devote a nice long chapter (chapter 9) to Text, offering plenty of opportunity for learning your way around this powerful class.

 Two other chapters I have found to be very useful are chapters 5 (Arrays) and 14 (Dates and Times).  Arrays are something I commonly overlook when I’m learning a new language, because they’re such a basic concept I feel as if I don’t need to devote much time for them.  As a result, I often need to consult a reference when doing anything beyond accessing elements.  At the same time, the recipes in the book dealing with Arrays aren’t all things you’d obviously want to do with them
(there’s one involving inserting items in the middle of an Array, which is unheard of in most languages). The same thing can be said for dates and times, even though I use them frequently it’s something I rarely commit to memory for any language, and it’s nice to have a reference handy.

 The breadth of topics covered in the book is good, and based on the chapters I’ve gone through already the depth of each has been sufficient to make me feel comfortable with the topic covered.  I can’t say this for many other Actionscript books I read, specifically the Actionscript 3.0 Language Reference (pdf format from Adobe) which covered each topic in such depth as to destroy all confidence in being able to effectively use the concepts.

The main reason I’ve enjoyed reading the ActionScript 3.0 Cookbook is because there are so many things I’ve never tried.  I’m sure I will be occupied by trying out these recipes off and on over the next year or longer.  In summary I’d recommend this book to any Flex developer who wants to develop a mastery of the ActionScript language a little bit at a time. 

I  have a lot of praise for Advanced ActionScript 3 with Design Patterns, by Joey Lott and Danny Patterson.  I purchased this book when I first started learning Flex and Actionscript for the purpose of becoming more familiar with Actionscript.  I was familiar with most of the common design patterns already and wanted to see their implemetation in Actionscript.

If you’ve read and understood what the Gang-of-Four (or even HeadFirst) had to say about design patterns, you probably won’t get much more with regards to that from this book.  Most of it served mainly as an interesting read and a little reinforcement.  However, toward the end of the book there are 4 chapters that covered material not directly related to design patterns, but concepts that I have come to realize are significant to gaining an appreciation for Actionscript.

Chapter 13 is titled “Working with Events”.  This chapter really helped me to understand how events are used in Actionscript and Flex (which is different enough than how they are used in Java or Visual Basic to warrant special consideration for someone learning Actionscript).

 Chapter 14 is titled “Sending and Loading Data”.  For someone first learning Flex or Actionscript figuring out how to get data from a database is one of the most frustrating experiences, especially for those used to scripting languages whose output is HTML (like JSP or PHP).  The book covers loading text files, loading XML via URLRequest, Flash Remoting, and Web Services.  It wanted only a little bit more explanation of why it had to be so roundabout, to make it a perfect explanation.  I’ve since come to understand why, but I could have benefitted from that understanding a bit sooner.

Chapter 15 is titled “E4X (XML)”.  Like getting data from a database, how to use XML is also a source of great frustration for beginners.  Lott and Patterson give a good overview of using it, and from them I learned to treat everything as an XMLList, unless I know it’s XML.  I’ve done that and been more sane on account of it.

Chapter 16 is titled “Regular Expressions”.  This is one chapter I have yet to fully benefit from, but still an important concept as regular expressions have lots of uses both in and out of Actionscript.  I don’t have a gift for regexp like some seem to have, and I refer to this chapter frequently when I find myself in need of them.

For these 4 chapters alone, the book was worth the money.  In addition, I think someone less familiar with design patterns might also derive more benefit from the remainder of the book than I did, because it is well written and usually very clear.  One thing of less import, that I really liked about the book– only 272 pages (Deitel and Associates should take a leaf from it…)

Programming Flex 2, by Chafic Kazoun and Joey Lott, is without a doubt my favorite book about Flex (and therefore the greatest ever written).

Even though I have mastered many of the techniques and concepts presented in the book, I still find myself using it as my primary Flex reference, second only to the API documentation.  The reason for that is that all the examples in the book are succinct and to the point (contrast this with C++/Java: How to Program by Paul and Harvey Deitel, which I loathe on account of the excessive code in the book.  Note to Paul and Harvey: reading the programs is NOTHING like ‘entering them and running them on a computer’… notwithstanding the Live-Code™ approach).  The short and sweet examples allow Kazoun and Lott to cover a remarkable breadth of topics in under 500 pages.

The main reason I love it so much is that I got it at the right time, which is to say my understanding of Flex and Actionscript was at the right level to receive maximum benefit from the book’s content.  I have a fairly solid background in software development, and I had just finished the tutorials on Flex Builder’s Start tab.  I just needed a reference to help me take it to the next level, and Programming Flex 2 really came through for me as far as that was concerned.

The first chapter that really benefitted me at this stage was chapter 7, “Working with UI Components”.  It was more interesting to read than the API documentation, but provided enough details to expand my understanding of working with various components.  It seems I found a new chapter once or twice a week that filled a void in my understanding that was giving me trouble in my personal projects.

Even today, I went to it to look up some information on using scale-9 and discovered a whole wealth of information about skinning that I didn’t quite grasp the first time I went through it.  Even a year after first getting the book, it’s still providing value.  I expect there are other things in there I still haven’t fully appreciated.

This is a great book and I highly recommend this it to anyone, specifically beginning to intermediate level Flex developers looking to take their skills to the next level.