5 comments about Programming Firefox: Building Rich Internet Applications with XUL (Programming).

1. This is another book in which the author (or the publisher) couldn't be bothered to format its code samples. This would be so easy to do and I am sick of seeing this twisted, unreadable mess in my programming books.
   
   Nested code is not indented, braces commonly do not line up, and barely any care was taken to indicate scope at all. It is also littered with useless comments that do not indicate the purpose of the code it should be describing, but rather to mark that the end of a block of code has been reached. Having a try-block followed by the comment " // try" is nowhere near as useful to me as if the code would have been readable in the first place.
   
   The book is fairly respectable as a reference, however, and does make a nice complement to Essential XUL Programming, which is a little old but still quite serviceable.
   
   Overall I would not purchase this book again. Combining the above mentioned text with the xulplanet web site is quite enough. My summary of this book is that it has the potential to be useful, but is generally very irritating to read.



2. Back in 2005, I've read "Rapid Application Development with Mozilla" by Nigel McFarlane - pretty big and comprehensive (I think) book about Mozilla platform. I'm not a web developer but I always try to keep up with the latest developments in the industry, so I was looking for a book which covers Firefox peculiarities. That was my primary motivation for buying "Programming Firefox" by Kenneth C. Feldt.
   
   The book itself was a bit disappointment: it was not as comprehensive as I expected it to be (honestly, I thought it would be both comprehensive and slim - probably I was just asking for too much). The author employ "learning by doing" approach - in the first half of the book he develops a XUL application and explains things required to build it. Although this approach works really well for the magazines where you are limited in space, when you read a book you expect more general discussion which is applied to the specific subject only at the very latest step. If you are trying to explain everything using only one (or very few) program(s) as a test base you will necessarily limit the discussion to topics relevant to that problem - which is again okay for the magazine but not for the textbook. The most notable omissions from the book in this sense are: whole XPCOM framework (several interfaces and the way to create the components via XPConnect are mentioned briefly but it does not go any further solving problems relevant for the example application); keys, keysets and commands (nothing was said about it), Mozilla-specific CSS attributes (-moz-appearance is mentioned briefly), complicated layouts (deck, stack and the friends). I would also prefer to see brief introduction to JavaScript.
   
   A strong part of the book is that it's not limited to XUL/XBL - SVG, XForms and canvas tag are also mentioned. Unfortunately (and again), only XForms are covered throughly - when it comes to SVG you see small subset of features required to build bar diagram.
   
   As mentioned in the previous review, code is formatted badly (and actually I can object some of the techniques employed therein) - but I don't think its a big drawback of the book. The worse thing is that there is too much code - not only snippets, but the whole programs. They take up precious place ans are hard to read from the paper anyway.
   
   In the conclusion, it's not a brilliant book on the subject. Given the absence of the modern books on XUL programming and its relatively small size in terms of pages, I recommend you buy it if you want to get a taste of Firefox development, but if you need an old-school textbook, better opt for "Rapid development..." or whatever. I'm giving it four-stars anyway - there is no point for being too strict to the author and the publisher who are willing to promote good under-documented technology.



3. Well well... I bought this book a month ago to develop a Firefox extension for work. I must say it's a terrible book. There's no pedagogy, and the content is VERY incomplete.
   It deals mostly with XUL widget programming. it will teach you how to set the developer environment, how to interfere with the user, how to deploy THAT'S IT. poor examples, bad coding practices... I spent 60 box for this useless book...



4. Kenneth C. Feldt's PROGRAMMING FIREFOX is recommended for advanced computer libraries catering to programmers: it blends a tutorial and a programmer's reference under one cover, covering XUL's interface and capabilities and including a review of Firefox technology, applications management, and more. Any designer working on standards-based Internet projects needs PROGRAMMING FIREFOX: it covers all the basics and encourages a more in-depth understanding of Firefox's potential.



5. I wanted to learn how to build a small Firefox
   extension. It looks like this book will help.
   It seems to be technically accurate and thorough.
   On a sentance by sentance basis it's also reasonably
   well-written. But as a whole it doesn't come together
   well enough to get a high mark. I didn't return it.
   That's the best I can say.

5 comments about Secure Programming Cookbook for C and C++: Recipes for Cryptography, Authentication, Input Validation & More.

1. To be truthful, I bought this book because the "gang" I hang out with is mentioned in the Acknowledgments section of the book. That was the ONLY reason when I sent money to Amazon.Com and purchased it for the dusty collection on my bookshelf.

   But, when I got it and chuckled over the Acknowledgements section, I started to mindlessly flip through the book. Mindless page flipping soon turned to semi-conscious scanning. Semi-conscious scanning soon turned to serious reading. I find myself reading the book more and more, jumping back and forth between sections I find interesting and useful.

   As a Windows C++ programmer for in-house tools, I do not dwell much on secure programming concepts. Yes, this is very, very bad way to program, so those of you reading this review should not try it at home. This book has shown the errors of my ways, revealed security issues that I have overlooked by accident or on purpose and gave concepts and examples that I can apply in my projects.

   This book is one reference that I will be going back over and over again. The authors and editors have done a wonderful job to make the reading flow nice and easy. It is also very well laid out by stating the problem you may encounter, followed by a solution and then detailed discussion section with code samples.

   For any C/C++ programmer making software to be used by more than one person, this reference book is a must.

   You can still read the Acknowledgments and marvel at my name on there, of course.




2. This well-written book covers a lot of topics that I have not read in other books.

   Its strengths include:

   --Good coverage of cryptography programming
   --Task-oriented solutions to specific programming problems
   --Easy to navigate "cookbook" style ("with recipes" as the authors call them)

   However, some areas of improvement might be:

   --Could use more coverage of important subjects (buffer overflows, etc.)
   --spends a lot of space on narrower examples (like explaining certain APIs that are documented well online)
   --Sometimes jumps into material without much background explanation (which was confusing for me)

   It is probably not the first book you should read on the subject. This is more of a recipe guide that is useful if you get stuck on coding a particular topic that happens to be covered. The authors have done a good job of explaining what coverage they do and don't include.




3. This is simply a great book for anyone using C or C++.

   These guys literally wrote the book on secure code.

   Read it!




4. If you are not sure that you need this book, then you probably don't. But if there is something it the table of contents that you've got to know, and you've got to get it right, then this would be a good book to have. Chapter 12 on Anti-Tampering was a really enjoyable read, though probably a futile task.



5. This is a well-written and example oriented book for C/C++ programmers that covers secure programming in all aspects. I had been using this book for last one year now and It helps me as a quick reference and also real source code demonstrating practical approaches that can be incorporated into their software projects.
   
   The book needs a little update but still helps any aspiring C/C++ programmer involved with crypto.

4 comments about Computers as Theatre.

1. Laurel is quite the scholar - she's got experience and learning in the fields of theater and human-computer activities. Laurl applies Aristotle's Poetics to computer software design. I especially liked her comparison of computers to theatrical production - a tremendous amount of action goes on "behind the scenes." As Laurel points out, dramatic expression is a type of virtual reality; anything we develop with computers has a very long heritage. A must-read for the digerati



2. I finished reading "Computers as Theater" by Brenda Laural yesterday. The book has many good ideas in it, and it may well be worth reading just to pick these up.

   It is also one of those books which does not do a good job of unifying its material, in my opinion. Rather than being a progression of ideas that builds to some intellectual climax, it meanders through various interesting points not quite aimlessly. The book introduces two useful diagrams: 'flying wedges' which describe how the space of possibilities in a drama go from the 'possible' to converge on the 'necessary', and 'freytag triangles', which measures the rise and fall of a plot. If these are used to describe this book (a slight abuse?), it doesn't fare well. The freytag diagram never peaks, and the wedge doesn't converge to the 'necessary'. This may be because the objectives for the book were not clear. As a reader, I didn't realize she was not (mostly) speaking to the modern commercial software world for quite a while into the book. The book also ended with two chapters about virtual reality (the substance, not the hype), and I was left wondering if perhaps *this* was what the book was really about (if so, I didn't see it coming).

   All that said: there are many good ideas in the book, some of which will make you stop and think for a while (e.g. those diagrams). It is valuable because of this. As an individual, I simply wish the book had been better structured, for I'd have gotten more out of it.




3. ... because it reminds me a great deal of Bruce Lee's "Tao of Jeet Kune Do." In that book, the reader is warned in the preface to approach the book actively with pencil in hand to jot notes and draw lines between connected ideas. I have done this with Brenda's book. It will take about 6-7 reads and lots of mental connections before everything starts to gel.

   It is a new "Way" of thinking, and, indeed, is so far ahead of any way we design software now that many ideas that this book suggests still need extensive research to even understand how to implement. (e.g. Freytag graphs as a way of structuring software/task flow to provide a pleasing HCI, and Brenda's Principles of Intelligent Computer Agency as a means for implementing truly AI agents with personality and emotions).

   Along with the wonderful head rush of compelling new theory, she also takes the second half of the book to explain principles of software design that you can implement in your programs _now_, and also takes the time to introduce you to fascinating HCI research offshoots like Programming by Demonstration.

   It is wonderful writing, and her ideas and concepts continually refresh and remind me why I am in such an exciting field.




4. The idea that is perhaps most central to this book is that if you design the action involved in a user interface, the design of all other objects in the domain will follow. To support this, Laurel reconciles the seemingly disparate and relates user interface design with producing a play in theater. For example, the way she brings in the Freytag triangle works very well.

   This said, I wish I wish that we would see a book from Laurel (or from one of her other usability guru companions) that treats with more recent issues-- particularly the Internet. I think she's one of the smartest people out there in the field, and I try to read what she's written, but I'm getting tired of reading about Habitat, Guides, and the Holodek on Star Trek. That's not the fault of the book, given that it came out pre-Internet hype, but it did inflect the reading experience with some weariness.

5 comments about Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools.

1. First, the Software Factories concept is great in some points while it combines model driven design and domain specific languages. If it is a real future for software development you have to read and take your conclusions.
   
   But..this book is too Microsoft biased. As written by a MSFT emplyee this is kind of expected but the fact is that the guy makes everything to say C#/.Net is the future of Java. This includes saying that JIT compilation was first introduced by .Net, that JavaBeans are a convention that are evolved in C# by delegates and properties and lots of other tries to make people believe that .Net is an evolution of the Java platform. I think this really compromises the book and would be much, much better if it just used C# and forgot all comparisson.
   
   I'd suggest that people intersted in MDA, DSL and new trends read this book but just skip all the Java bashing.



2. With four authors the writing is a bit varied toward the middle to the end, but overall this book is just plain boring; I find this to be a fascinating subject and even I was bored. Go figure.
   
   My main gripes about this book (boredom aside) are:
   
   1) The coverage of DSL's (domain specific language): the authors repeatedly state that the cost of dsl developement can be prohibitive. I dispute this arugument as languages such as ocaml make the implementation of arbitrary languages realatively straight forward to people with the know how.
   
   2) They claim domain specific languages are more powerful than general purpose languages. Their concept of 'power' seems to be skewed toward some weird metric I'm not familiar with.
   
   3) The Microsoft bias is just annoying. Doubly annoying because if anything happens in this space it will be from the open source crowd, imho.
   
   4) There's alot of repetition; every other page the authors are remaking the case for increasing abstraction in developement tools because 'compilers increase abstraction from assembler'. Okay, I got it the first time, you don't have to repeat it fifty times.
   
   I think it's inevitable that something like software factories will emerge in time. This book gives an overview of the authors vision of where things are going. But they're academics writeing to an academic crowd and that's how the book reads.



3. This book provided insightful coverage of what I think is a fascinating topic. THe author organizes the material in a logical manner making it easy to transition from one topic to another. I would have liked more illustrations, but what was supplied was enough for me to understand everything. Very recommended!



4. Wow! I bought this book a long time ago and it lived on my "bibliophile" stack of bought but unread gems. It's a stunning book if you seek to understand the decomposition of complexity in modern software applications and the complex deployment architectures they work in. My only concern is the book is not an engineering book - there are no mathematical models of scale and performance for distributed decompositions. It has a excellent description of aspect oriented programming which I learned from. The authors could also benefit if they discovered the ideas in Carliss Baldwin's superlative "Design Rules" book and brought those ideas into their own discussion of the software construction domain. This is a WONDERFUL book for enterprise architects.



5. This book is interesting but it is poorly organized. It seems that ideas are mixed, and chapters repeat the same ideas again and again, sometimes calling them in different way.

5 comments about Data Structures Using C and C++ (2nd Edition).

1. This book is probably the worst DS book with c/c++ in the market.
   The explanation is very convoluted and follows an ancient coding style which you are unlikely to be familiar with. The c++ code is often jumbled with the algorithm/pseudocode part creating code which is neither easy to implement(if it was totally in c/c++) nor understandable(if it was totally in pseudocode).
   There are many examples masquerading as executable code which in fact do not compile.
   Beginners should definitely stay away - which is kind of a moo point since the book is geared for that audience.
   One of the better books is Introduction to Algorithms by Cormen et al. The algorithms explained here are very easy to implement, far more than most books written for any programming language! If you still have trouble implementing algorithms then i suggest that you brush up on C++/C/Java with the How to Program series which cover elementary Data Sructures



2. Received book in timely manner and in very good condition. Good seller. Fast.



3. If you don't have good knowledge about C then this book will be confuse beacuse this book is about DS and NOT about C programming. Certainly it use some C/C++ to write implementations of DS but not for teach C/C++. If you really know C then you can buy it. In my case it was a very good book and I get very good knowledge about DS.
   
   By the way, I bought and read this book in spanish, it was a good translation.



4. Many of the criticisms here are justified, but IMHO there are no good DS&A books. I have Binstock's book and it has lots of errors, although code listings on the website that I tried to compile did finally work, the stuff on the disk didn't. Sedgwick's stuff is about as muddled in C as this book is. Knuth is still wedded to his own private assembly language and a half a dozen others I own are so unremarkable I won't mention them.
   
   What I like about this book is they mention algorithms that no one else even seems to know about - like the interpolation search. I don't need a lot of hand holding as I have been programming longer than most reviewers have been out of diapers, and it is annoying when stuff you paid for turns out to be nothing more than misdirection, but all of these books seem to be more in the form of some theory and some p-code disguised in some commercial language's syntax, so until editors and buyers insist on quality, use these books as guidelines.
   
   When writing an in-memory database about 10 years ago I had to write an interface to a COBOL system that had the most convoluted method for identifying record types imaginable. The next record read could be one of about 300 possible record types. Running the routine that could discriminate between the 300 odd records was very expensive and required some sort of optimization. Observing that the records tended to present themselves in small groups of identical record types I wrote a type of elevator algorithm where a list of recently seen record types was constantly resorted and used to cue the guesses used to interrogate the next record I'd get(). By the time I tackled this problem I had written dozens of sort and search algorithms and had been programming in C for over 5 years for a Wall St banks. This book was the only book on DS&A that suggested this approach.
   
   I could give a half dozen other illustrations to demonstrate the value of breath of coverage too, but suffice it to say you only need one gem per book to make it worthwhile buying. FWIW, I found out the hard way that even K&R has errors, and a book like Harbinger and Steele's is still to be preferred to the bloat tomes coming from Wrox. The real problem for writers of these books is professional programmers, with rare exceptions, no longer use DS&A, they use Java, STL, C# (should be C dullard - C without pointers ain't C people! Read the C standard library and get a clue!), or MS's C++ container classes and have no clue what they are doing. (Don't make me think, I have money to make) That leaves students as almost the sole reader group for these books and you can't get into much depth without losing the reader there.



5. This book is simply a rehash of the same book that began with Pascal. The coverage of vital concepts is extremely confusing, which leads the reader to believe that the authors are confused about the concepts themselves.
   
   Many of the concepts can be much better understood with Sedgewick's book.
   
   Clearly, the authors have very limited large-scale programming experience with the language.

1 comments about Teaching and Learning with Microsoft Office 2007 and Expression Web (2nd Edition).

1. This book is absolutely abysmal. I program in 3 languages. I'm required to take a technology class in my Master's program. This book is an affront to my intellect. The man who wrote this book has no experience ith either computers or children. He's a psychologist.
   
   Here's how you know the book is typically self-indulgent educational tripe - there's a self-assessment rubric on page 3 on whether or not you should buy the textbook.
   
   Then there are the idiotic assignments. One of them is putting frilly star borders, wordart and a picture of a whale on a business letter to be sent to parents (36). That's a great way to be taken seriously.
   
   The assessments are absurd, and the book doesn't tell you anything you can't already learn for free by clicking "help". Avoid if you can.

No comments about Microsoft Dynamics AX 2009 Programming Unleashed.

5 comments about Process Improvement Essentials: CMMI, Six Sigma, and ISO 9001.

1. There are currently three major international standards in process improvement: CMMI, ISO 9001, and Six Sigma. In the past, I have had a hard time finding insights about the commonalities and differences between these three standards. Most of books and instructors focus on one of these standards. Luckily, I stumbled on this book.
   
   I have never expected a process book to be that interesting and entertaining to read! I found the author's style very engaging; most of the book, except pieces covering specific details of each standard, is *not* "dry" or boring, which I can't say about other process books that I looked at. Secondly, the author's knowledge and experience make everything logical and convincing, even comforting.
   
   The book consists of two parts. The first one is filled with real life examples designed to show an executive or a skeptic (in my past past experience, these words were synonyms) that process must be managed and can be improved. In other words, if one wants a business to succeed, he better understands the processes comprising that business, monitors and measures them, and improves these processes continuously.
   
   The second part of the book is split into three chunks: CMMI, ISO 9001, and Six Sigma. Each of these three chapters have an excellent overview of a standard's history, its main gist, and the differences with the other two standards, as well as a concise descriptions of its concepts and components.
   
   This book will be a pleasant surprise for those who don't have time to compile numerous sources on the topic, or who fall asleep reading traditionally written process books.



2. This book was very easy to read and understand. Unlike other books out there, this book didn't put me to sleep. It's well organized and got me up to speed very quickly. I needed a quick introduction to CMMI since taking my new job.



3. This is a good book if you're not bound to a specific model/framework. It gives recommendation for CMMI, Six Sig and ISO process frameworks. Easy read.



4. I've had the dubious "pleasure" of reading process improvement books that would make your eyes bleed. Fortunately, this isn't one of them... Process Improvement Essentials: CMMI, Six SIGMA, and ISO 9001 by James R. Persse. This is a perfect "first look" at the subject for someone who doesn't yet know what they don't know...
   
   Contents:
   Part One - Process and Process Improvement: Introduction; The Case for Process; Establishing Your Process Program; Sustaining Process Improvement
   Part Two - Three Major Process Improvement Standards: ISO 9001:2000; The Capability Maturity Model Integration (For Development); Six Sigma; Considerations For Adoption
   Index
   
   The problem with many books on this subject is that they dive into the details of a specific program before you really understand *why* you're doing this in the first place. That's fine for someone who has already decided on a particular approach, but it's completely unsuited to someone who really just needs to get a broad overview. Persse solves this issue by starting out with a high-level look at Process Improvement... why it's necessary, how it works, and how it's best implemented. Based on his years of experience, he is able to point out the mindsets and approaches that will either jumpstart or doom a process improvement initiative. Only after the reader has the mental framework does he introduce details on the three major process improvement frameworks commonly seen in the market today. There's enough detail in each of the chapters to understand how the framework functions and what it's designed to resolve, but not so much that the reader (at the targeted level) decides it's all too complicated and walks away. After reading this book, you should know what it is that you don't know, have an idea as to what areas to focus on, and be prepared to take *intelligent* next steps. And before you decide to sink hundreds of thousands of dollars into a program, that's a great place to be starting at.
   
   I'd consider this "required reading" for anyone contemplating a process improvement initiative. Time and dollars invested here will ensure much better value for the money you'll end up spending down the road...



5. I bought this book to familiarize myself with process engineering concepts prior to taking a position as a semiconductor process development engineer. This book is not very useful for engineers, but is useful for managers or laymen who need a basic concept/understanding for Quality Control Systems.
   
   Other than that, it is very easy to read.

5 comments about Sams Teach Yourself Web Services in 24 Hours (Sams Teach Yourself).

1. To learn how to build and use web services, you first must determine what they are and how they differ from current technologies used in the development and use of web pages. With the exception of being based on eXtensible Markup Language (XML), they are only different in degree from widely used web technologies such as Active Server Pages (ASPs) and Java Server Pages (JSPs).
   The authors do a good job of explaining what web services are and how they differ from other technologies. They also do not fall victim to the evangelical bug, being very explicit in pointing out the disadvantages of web services as well as the advantages as a chapter is devoted to each point. Another chapter is devoted to comparing how web services differ from other technologies such as ASPs, JSPs, Common Gateway Interface (CGI), Common Object Request Broker Architecture (CORBA) and Java Remote Method Invocation (RMI).
   The middle section of the book is devoted to describing the architecture of web services , the basics of XML, how web services communicate using XML and Simple Object Access Prototcol (SOAP), how web services are described using Web Services Description Language (WSDL), and how to advertise a web service using Universal Description , Discovery and Integration (UDDI). While not detailed, it is a complete introduction to all of the steps you must go through to create a complete web service that others can use.
   The third section is devoted to describing several tools that can be used to build web services. Commercial tools such as Apache Axis, Java, .NET, IBM Websphere and BEA Weblogic are covered and the authors are to be commended in also showing how they can be built using inexpensive and free toolkits. Finally, the last section covers topics such as the interoperability of web services, how security is included in web services and what some of the future trends in web services may be.
   This book is an introduction to web services, so it is not possible to learn all of the specifics you need to build complex web services from it. However, if you are a beginner, there is enough information to get you started and to help you make decisions concerning whether you want to start building them.



2. As someone who knew ABSOLUTELY nothing about web services when I started, this book was the best of the 1/2 dozen titles I perused because it balanced high level understanding with the nitty-gritty and code examples. I found this book far most useful than titles such as 'Web Service: A Manager's Guide' and '.Net Web Services for Dummies'.

   As someone who is not particularly technical, the code segments were still very useful in understanding what is going on. Without looking at a little code, understanding web services and its components becomes too esoteric. Why would you just describe an elephant when you can also provide a picture.

   As someone who was just trying to understand web services and had no interest in comparing specific vendors' web services offerings, the chapters on commercial tools such as Apache Axis, Java, .NET, IBM Websphere and BEA Weblogic, and their specific pros/cons was not terribly interesting to me. But I could see how they would be valuable to an IT Professional.

   The book does not really take 24 hours. Overall, I spent 9 intense hours working through this book to developing a good grasp of the technology. I recommend the opening chapters of 'Understanding .NET' by Chappell as a great supplement. Chappel gives great brief high-level descriptions on the components of web services and how they came about.

   ...




3. The "Teach Yourself" series has done little to impress me until the arrival of this book. XML-based web services are getting traction as a truly standard way of enabling the service-oriented systems architecture. An architecture where systems can be built to expose services in such a way as to make it easier to integrate enterprise systems has been built many times already, but always ending up with constraints related to programming language, operating system and hardware. This book provides a good introduction to XML-based web services components including XML schema, WSDL, UDDI, SOAP and HTML with a comparison to the past attempts including DCOM and CORBA. The code examples require some analysis but are pretty helpful once you've taken the time to decode the XML and the scenario examples / case studies provide an interesting context to see how XML-based web services can be applied.



4. Book was practically new just like it was stated, and it didn't take more than 2 weeks to come which was PERFECT! There was almost no difference between this book and the new books =]



5. To get right to the point, this book is written in a very easy to read and accessable style, with just the right diagrams and illustrations in the right places to aid in understanding.
   
   I've never programmed with web services, but I need to know the terminology and basically what it's all about. This book served me well in this capacity.
   
   It is not a book that goes into detail as to exactly how to do programming. This book is not technology specific, but rather after spending the first half easing the reader into exactly what web services are and why they exist, shows at a high-level how they are created with several different common technology platforms.
   
   Also, there is a chapter on real world web services so the reader can go out and see exactly what web services look like when they are deployed in the "real world".
   
   If you've never programmed a web services application before, I seriously doubt that you'll be able to do it after reading this book, at least nothing more than a simple example application. And in that sense, the title is a bit misleading. Perhaps it should have been "Introduce yourself to web services in 24 hours."
   
   So, I can see how a certain type of reader might be dissapointed, but this book is exactly what I needed when I needed it.

5 comments about Programming Flex 2: The Comprehensive Guide to Creating Rich Internet Applications with Adobe Flex (Programming).

1. This is a solid, well written into to Flex 2. I would highly recommend this as a starting to learning Flex 2 or 3. In about a week's reading time you will have a well grounded knowledge of what Flex is capable of. After reading this (along with the documentation provided by Adobe) I'd highly recommend: ActionScript 3.0 Cookbook; Essential ActionScript 3.0; and Flex Solutions: Essential Techniques for Flex 2 and 3 Developers.



2. Programming Flex 2: The comprehensive guide to creating rich media applications with Adobe Flex is a great book for more advanced Flex developers. This book covers many important topics like working with UI components, advanced component concepts, working with media and data, client and remote data communication just to name the few. The authors, Chafic Kazoun and Joey Lott, are very experienced long-time Flash developers. They are well known in the Flash community, and are among the elite of the Flash development world. Chafic and Joey has been using Flex for a long time and it can be noticed by reader during reading this book which is full of practical leads.
   
   This book is intended for anyone looking to learn more about Flex 2. The authors recognize that the audience for this book represents a very diverse group of people with many different backgrounds. In my opinion this book is a great resource but not for the beginners. Lots of original ActionScript and MXML code examples help reader to look deeper inside Flex 2 internals.
   
   I definitely recommend this book!



3. Reading the reviews for this book made me nervous about picking it up in the first place, but I'm glad I did. I'm primarily a J2EE developer wanting to get his feet wet in the world of Flex2 RIAs, and the authors seem to have written this just for someone like me. And in that respect, the topics are at the right level of depth - the authors clearly indicate that this is not meant to be used as an API reference.
   
   Flex 2 can be a bit much to bite off, even for experienced programmers, since it sits over a very mature and complex development platform (Flash Player) that has its own established authoring tool. Happily, the authors tend to chart their course firmly through the Flex Framework, avoiding diversions into Flash Player arcana (which some other books either assume you already know, or visit too briefly to be of much help.)
   
   The breadth of topics covered is also awesome - whether its Web services, states/transitions, event dispatching/handling, and the use of the free Flex SDK.
   
   That last one is of particular interest to me since I'm not a fan of the Deux Ex Machina aspects of IDEs, especially when I'm learning a new language/framework. Hence, being able to see how everything fits together using just the Flex SDK and mxmlc is a lot of fun.
   
   I also don't particularly like long, artificial examples that proceed from chapter to chapter, which means that you can't really jump into a topic that interests you without first having read all the previous history of the application being developed. Fortunately here, each chapter can be read by itself, and in any order. In fact, I skipped over many of the UI and media chapters just to get to the web services treatment which is closer to the end.
   
   To summarize - if your background/needs match mine, then this book will be well worth a visit. You may not leave knowing everything, but you'll have the 3000 foot overview which will position you better to ask the right questions, and to determine which topic has the most interest for you. (Of course, you might choose to wait for the Flex 3.0 edition of this book.)



4. It is a well organized book.
   However, some example codes are incorrect.
   I find this problem in many of O'Reilly books and am not sure if they test all the source codes before they publish their books.
   It is really annoying.



5. This is generally a well written overview book. Its chief problem is that it never gets beyond the basics, and that the "Flex Developer Guide" that Adobe provides for free on their web site is far superior.